home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / util / misc / gadmget2.lha / GadMget / GadMGet.source.lha / gadmget.c < prev    next >
C/C++ Source or Header  |  1995-08-05  |  103KB  |  4,317 lines
  1. /* GadMGet.c  by Jeremy Friesner -- jfriesne@ucsd.edu  
  2.    Version 2.05, released August 1, 1995*/
  3.  
  4. #ifndef MGET_C
  5. #define MGET_C
  6.  
  7. #define INTUI_V36_NAMES_ONLY
  8. #define MAXFILELINELENGTH 300 
  9. #define MAXFILENAMELENGTH 300 
  10. #define CHAR_NUL        (char)0
  11. #define CHAR_SPACE        (char)32
  12. #define CHAR_NEWLINE         (char)10
  13. #define CHAR_ESCAPE         (char)27
  14. #define CHAR_RETURN         (char)13
  15. #define INVALID 666
  16.  
  17. #define FIND_REQUESTTYPE     0
  18. #define LINELENGTH_REQUESTTYPE     1
  19. #define OUTPUTFILE_REQUESTTYPE     2
  20. #define SELECT_REQUESTTYPE      3
  21. #define DESELECT_REQUESTTYPE    4
  22.  
  23. #define SEARCH_FORWARD         1
  24. #define SEARCH_BACKWARD     2
  25. #define SEARCHTYPE_BOTTOM     1
  26. #define SEARCHTYPE_TOP         2
  27. #define SEARCHTYPE_NEXT     3
  28. #define SEARCHTYPE_PREVIOUS     4
  29. #define SEARCHTYPE_FORWARD     5
  30. #define SEARCHTYPE_BACKWARD     6
  31.  
  32. #define SORTBYDIR          1
  33. #define DIRNAMESIZE         10
  34.  
  35. #define SORTBYNAME         2
  36. #define NAMESIZE         20
  37.  
  38. #define SORTBYDESC         3
  39. #define DESCSIZE         42
  40.  
  41. #define SORTBYSIZE         4
  42. #define SIZESIZE         5
  43.  
  44. #define SORTBYAGE          5
  45. #define AGESIZE          5
  46.  
  47. #define TREESORT           1
  48. #define BUBBLESORT         2
  49.  
  50. #define ACTION_NONE        0x00
  51. #define ACTION_SAVE        0x01
  52. #define ACTION_OUTPUT        0x02
  53.  
  54. #define DEFAULT_EXECNAME    "GadMget"
  55.  
  56. #include "GadMget.h"
  57.  
  58. extern UWORD lastcode;
  59. extern ULONG appwinsig;
  60. extern struct NewGadget mgetNGad[];
  61. extern struct Window *findwindow;
  62. extern struct AppMessage *amsg;
  63. extern struct MsgPort *awport;
  64. extern struct AppWindow *appwin;
  65. extern struct TextAttr listfont;
  66.  
  67. extern LONG lTreeTicker;
  68. extern LONG lTreeSubTicker;
  69. extern char *sTreeWriteHere;
  70. extern char *szTickerString;
  71.  
  72. FILE *fpOut = stdout;
  73. int IntuitionBase; 
  74. ULONG winopenerror, lockscrnerror;
  75. ULONG handlereturn;
  76. BOOL done=FALSE,BStartedFromWB=FALSE;
  77. char windowtitle[95] = "Loading...";
  78.  
  79. char sListFontName[36] = "";
  80. int nListFontSize = 0;  /* Default to a bad value */
  81. char version[] = "$VER: GadMget V2.05";
  82. __far char template[] = "Template:  GadMGet FILE/A,OUTPUT/K,LINELENGTH/K,TOP/K,LEFT/K,\
  83. WIDTH/K,HEIGHT/K,PUBSCREEN/K,WBSCREEN/S,DEFPUBSCREEN/S,NOFILES/S,GETREADMES/S,\
  84. NOPARSE/S,CASESENSITIVE/S,SORTCASESENSITIVE/S,SEARCHCASESENSITIVE/S,NOCOMMAND/S,\
  85. NOSPLIT/S,NOAPPWINDOW/S,COMMAND/K,NOSIMPLEPATHS/S,NOCD/S,HEADER/K,FOOTER/K,\
  86. FONT/K,FONTSIZE/K,KEEPBLANKLINES/S,KEEPGETSORT/S,KEEPFILESORT/S,FILESORT/K,\
  87. GETSORT/K,AMINETPATH/K,EOL/K,COMMENTCHAR/K,OMITCOMMENTS/K,LOADBUFFERS/K,\
  88. CLOSEACTION/K\n";
  89. char pnamestring[20],searchstring[MAXFILELINELENGTH];
  90. char szPubScreenName[40],*pubscreenname = NULL,defDir[200],defFile[40];
  91. char szCommandString[40] = "mget ";
  92. __far char inputfile[MAXFILENAMELENGTH]="ram:RECENT";
  93. const char szBookMark[]="| --- GadMGet: Begin Selected Files --- ";
  94. char sEndOfLineString[10] = "\r\n";
  95. char sAminetPathString[50] = "../../";
  96. __far char sOutFileName[MAXFILENAMELENGTH]="";
  97. __far char szHeaderFile[MAXFILENAMELENGTH];
  98. __far char szFooterFile[MAXFILENAMELENGTH];
  99. char sMultiSelect[150]="";
  100. __far char szFilePattern[50]="#?";
  101. char cCommentChar = '|';
  102.  
  103. char *pcWhatToAbort;
  104. char *pcExecName=NULL;
  105.  
  106. int nTopListTop, nTopListHeight, nBottomListHeight;
  107. int nSortType[2] = {SORTBYDIR, SORTBYDIR};
  108. int nKeepSorted[2] = {FALSE, FALSE};
  109. int Not[2] = {TRUE, FALSE};        /* NOT lookup array */
  110. int nForTreeSortUseOnly;        /* only global because nested functions ain't happenin!  Don't use elsewhere! */
  111. int nLoadBufferSize = 30 * 1024;     /* default = 30k */
  112. int nCloseAction = ACTION_OUTPUT;    /* default = output on close box click */
  113.  
  114. struct List *lForTreeSortUseOnly;
  115.  
  116. static char *szLoadBuffer1 = NULL;
  117. static char *szLoadBuffer2 = NULL;
  118. static char *szLoadBuffer3 = NULL;
  119. static char *szLoadBufferT = NULL;
  120. static char *pcLoadCurrent = NULL;
  121. static char *pcEOFat       = NULL;
  122.  
  123. /* Input column info */
  124. static int nNameCol = 0;
  125. static int nKCol    = 35;
  126. static int nDirCol  = 21;
  127. static int nAgeCol  = 35;  /* Note that this should be the RIGHT side of the age string! */
  128. static int nPlusCol = 36;
  129. static int nDescCol = 37;
  130.  
  131. /* default flags */
  132. int     screentype         = USE_CUSTOMSCREEN,    
  133.     getreadmes        = FALSE, 
  134.     filesflag          = TRUE,            /* get .lha files */
  135.     filelist_length     = 0,             /* no files loaded */
  136.          getlist_length        = 0,            /* no files selected either */
  137.     search_index        = 0,            /* buffer at first item */
  138.     mgetfind_findtype       = SEARCHTYPE_FORWARD,   /* global var used between mgetfind* */
  139.     simplepaths         = TRUE,            /* don't use ncftp style mgets */
  140.     searchcasesensitive     = FALSE,
  141.     sortcasesensitive       = FALSE,                    
  142.     maxoutputlinelength     = 254,             /* shell's limit */
  143.     requesttype             = FIND_REQUESTTYPE,     /* subwindow is for string searches */
  144.     nSortAlgorithm          = TREESORT,        /* default sort type */
  145.     appwindow         = TRUE,            /* = YES */
  146.  
  147.     omitcomments        = FALSE,        /* load comment lines */
  148.     screenisopen         = FALSE,        /* = NO */
  149.     windowisopen         = FALSE,         /* = NO */
  150.     noparse         = FALSE,        /* = yes, parse */
  151.     nocommand        = FALSE,        /* = yes, generate command */
  152.     nosplit         = FALSE,        /* = yes, split */
  153.     nocd            = FALSE,        /* = generate CD commands */
  154.     mgetNGad_height     = 248,            /* default first listview height */
  155.     keepblanklines        = FALSE;                /* = don't show blank lines */
  156.  
  157. ULONG kbytes_selected = 0;                                
  158.      
  159. UWORD     windowwidth     = MAXINT,    /* window will be sized to fill */
  160.     windowheight      = MAXINT,    /* screen unless these are */
  161.     windowtop     = 0,         /* overridden by parameters */
  162.     windowleft     = 0;
  163.         
  164. void *findvi = NULL;
  165.  
  166. struct Library *Intuitionbase    = NULL;
  167. struct GfxBase *GraphicsBase    = NULL;
  168. struct Library *GadToolsBase    = NULL;
  169. struct Library *UtilityBase    = NULL;
  170. struct Library *AslBase        = NULL;
  171. struct Library *IconBase    = NULL;
  172. struct Library *WorkbenchBase    = NULL;
  173.  
  174. struct IntuiMessage *message     = NULL;
  175. struct List *filelist         = NULL, 
  176.         *getlist         = NULL;
  177. struct Node *search_current     = NULL;
  178. struct Gadget *findgadlist     = NULL;
  179. struct TextFont *listfontdata     = NULL;
  180. struct DiskObject *appIconObj   = NULL;
  181.  
  182. __chip UWORD waitPointer[] =
  183.     {
  184.     0x0000, 0x0000,
  185.     0x0400, 0x07c0,
  186.     0x0000, 0x07c0,
  187.     0x0100, 0x0380,
  188.     0x0000, 0x07e0,
  189.     0x07c0, 0x1ff8,
  190.     0x1ff0, 0x3fec,
  191.     0x3ff8, 0x7fde,
  192.     0x3ff8, 0x7fbe,
  193.     0x7ffc, 0xff7f,
  194.     0x7efc, 0xffff,
  195.     0x7ffc, 0xffff,
  196.     0x3ff8, 0x7ffe,
  197.     0x3ff8, 0x7ffe,
  198.     0x1ff0, 0x3ffc,
  199.     0x07c0, 0x1ff8,
  200.     0x0000, 0x07e0,
  201.     0x0000, 0x0000};
  202.     
  203.  
  204. void debug(int a)
  205. {
  206.     fprintf(fpOut,"debug  %i\n",a);
  207.     Delay(80);
  208. }
  209.  
  210.  
  211.  
  212.  
  213. void EOLParse(char *sString)
  214. {
  215. char sTempString[50], sTemp2[2] = " "; 
  216. char * sCurrent = sString;
  217. int i=0, nStringLength;
  218.  
  219. if (sString == NULL) return;
  220. nStringLength = strlen(sString); 
  221. memset(sTempString,CHAR_NUL,sizeof(sTempString));
  222.  
  223. while ((i<(sizeof(sTempString)-1))&&(*sCurrent != CHAR_NUL))
  224. {
  225.     if (*sCurrent == '\\')
  226.     {
  227.         sCurrent++; i++;
  228.         switch(*sCurrent)
  229.         {
  230.             case 'r':
  231.                 strncat(sTempString,"\r",sizeof(sTempString));
  232.             break;
  233.             
  234.             case 'n':
  235.                 strncat(sTempString,"\n",sizeof(sTempString));
  236.             break;
  237.         
  238.             case CHAR_NUL:
  239.                 i = nStringLength + 1;    /* get out of the loop! */
  240.             break;
  241.             
  242.             case '\\':
  243.                 strncat(sTempString,"\\",sizeof(sTempString));
  244.             break;                
  245.             
  246.             default:
  247.                 sTemp2[0] = *sCurrent;
  248.                 strncat(sTempString,"\\",sizeof(sTempString));                
  249.                 strncat(sTempString,sTemp2,sizeof(sTempString));
  250.                 i++;
  251.             break;
  252.         }
  253.     }
  254.     else
  255.     {
  256.         sTemp2[0] = *sCurrent;
  257.         strncat(sTempString, sTemp2, sizeof(sTempString));
  258.         i++;
  259.     }
  260.     sCurrent++;
  261. }
  262. strncpy(sString,sTempString,nStringLength);
  263. return;
  264. }
  265.  
  266.  
  267.  
  268.  
  269.  
  270. /* If *index isn't NULL, that location will be set to the index
  271.    value of the tail of the list */
  272. struct Node * TailOf(struct List *thislist, int *index)
  273. {
  274.     struct Node *CurrentNode = thislist->lh_Head;
  275.     int nTempIndex = 0;
  276.     
  277.     /* traverse to tail of list */
  278.     while ((CurrentNode != NULL)&&(CurrentNode->ln_Succ != NULL))
  279.     {
  280.         nTempIndex++;
  281.         CurrentNode = CurrentNode->ln_Succ;
  282.     }
  283.  
  284.     if (index != NULL) *index = nTempIndex;
  285.  
  286.     return(CurrentNode);
  287. }
  288.  
  289.  
  290.  
  291.  
  292.  
  293.  
  294. /* Return index in list of the current 1st visible node */
  295. LONG ListViewTop (struct Gadget *gad, struct Window *win)
  296. {
  297.    LONG top;
  298.  
  299.     /* use Official attributes function if running under 3.0+, otherwise
  300.        hack into the Gadget struct to find out */
  301.    if (GadToolsBase->lib_Version >= 39)
  302.       GT_GetGadgetAttrs (gad, win, NULL, GTLV_Top, &top, TAG_END);
  303.    else
  304.       top = (LONG)(*(short *)(((char *)gad)+sizeof(struct Gadget)+4));
  305.  
  306.    return (top);
  307. }
  308.  
  309.  
  310.  
  311. /* return pointer to first visible node in thisGad, thislist */
  312. struct Node * ListViewTopNode(struct Gadget *thisGad, struct List *thislist)
  313. {
  314.     int nTemp = 0;
  315.     int nTop = ListViewTop(thisGad,mgetWnd);
  316.     struct Node *CurrentNode = NULL;
  317.  
  318.     CurrentNode = thislist->lh_Head;
  319.     while (nTemp < nTop) {CurrentNode = CurrentNode->ln_Succ; nTemp++;}
  320.     return(CurrentNode);
  321. }
  322.  
  323.  
  324.  
  325. int isAminetParsable(char *dataline)
  326. {
  327.     BOOL BValidLine;
  328.     
  329.     /* check to make sure string is a valid file line */
  330.     if ((dataline == NULL)||(dataline[0] == CHAR_NUL)||(dataline[Not[keepblanklines]] == CHAR_NUL)) return(FALSE);    
  331.         
  332.     if (!noparse)
  333.     {
  334.         if (((dataline[nNameCol] < '0')||(dataline[nNameCol] > 'z')) ||
  335.             ((dataline[nKCol] != 'K')&&(dataline[nKCol] != 'M')&&(dataline[nKCol] != '?')) || 
  336.             (dataline[nDirCol] < '0') || (dataline[nDirCol] > 'z') ||
  337.             (dataline[nDescCol] < 'A') || (dataline[nDescCol] > 'z') ||
  338.             ((dataline[nPlusCol] != '+')&&(dataline[nPlusCol] != '*')&&(dataline[nPlusCol] != ' ')) ||
  339.             ((filesflag == 0)&&(dataline[nPlusCol] != '+')))
  340.         {
  341.             /* Problem line--rescan! */
  342.             BValidLine = ReScanAminetLine(dataline);
  343.             if (filesflag == 0) return(BValidLine && (dataline[nPlusCol] == '+'));
  344.             else return(BValidLine);
  345.         }
  346.     }    
  347.     return(TRUE);
  348. }
  349.  
  350.  
  351. /* This function looks at an Aminet line and if successful, will update
  352.    the global n#?Col variables to reflect the columns found in this line
  353.    Returns 0 on failure (and won't update the global vars), or 1 on 
  354.    success (vars were all updated) */
  355. int ReScanAminetLine(char *dataline)
  356. {
  357.     BOOL BDone = FALSE, BFoundAgeAlready = FALSE;
  358.     int nCount = 0;
  359.     int nTempNameCol = -1;
  360.     int nTempKCol    = -1;
  361.     int nTempDirCol  = -1;
  362.     int nTempPlusCol = -1;
  363.     int nTempDescCol = -1;
  364.     int nTempAgeCol  = -1;
  365.     int nState = 0;     
  366.     
  367.     /* State 0 = haven't found filename yet */
  368.     /* State 1 = reading thru filename */
  369.     /* State 2 = haven't found directory yet */
  370.     /* State 3 = haven't found K/M thingy yet */
  371.     /* State 4 = haven't found weeks yet */
  372.     /* State 5 = Looking for plus symbol */
  373.     /* State 6 = Backtracking for age field */
  374.     
  375.     char *pcThisChar = dataline;
  376.     
  377.     if (pcThisChar == NULL) return(0);
  378.     
  379.     while((*pcThisChar != CHAR_NUL)&&(BDone == FALSE))
  380.     {
  381.         switch (nState)
  382.         {
  383.             case 0:        /* Looking for start of file name */
  384.                 if ((*pcThisChar >= '0')&&(*pcThisChar <= 'z'))
  385.                 {
  386.                     nTempNameCol = nCount;
  387.                     nState = 1;
  388.                 }
  389.                 pcThisChar++; 
  390.                 nCount++;
  391.                 break;
  392.             
  393.             case 1:        /* Reading thru filename */
  394.                 if (*pcThisChar == ' ')
  395.                 {
  396.                     nState = 2;
  397.                 }
  398.                 else
  399.                 {
  400.                     pcThisChar++; 
  401.                     nCount++;
  402.                 }
  403.                 break;
  404.             
  405.             case 2:    /* Moving over spaces after filename */
  406.                 if (*pcThisChar != ' ')
  407.                 {
  408.                     nTempDirCol = nCount;
  409.                     nState = 3;
  410.                 }
  411.                 pcThisChar++;
  412.                 nCount++;
  413.                 break;
  414.             
  415.             case 3:    /* Moving thru directory */
  416.                 if (*pcThisChar == ' ')
  417.                 {
  418.                     nState = 4;
  419.                 }
  420.                 pcThisChar++;
  421.                 nCount++;
  422.                 break;
  423.             
  424.             case 4: /* Looking for KCol */
  425.                 if ((*pcThisChar == 'K')||(*pcThisChar == 'M')||(*pcThisChar == '?'))
  426.                 {
  427.                     nTempKCol = nCount;
  428.                     nState = 5;
  429.                 }        
  430.                 pcThisChar++;
  431.                 nCount++;
  432.                 break;
  433.  
  434.             case 5: /* Looking for plus symbol, or the age number */
  435.                 if (*pcThisChar == '+')        
  436.                 {
  437.                     /* found the + */
  438.                     nTempPlusCol = nCount;
  439.                     nTempDescCol = nCount + 1;
  440.                     BDone = TRUE;
  441.                 }
  442.                 else if (((*pcThisChar >= '0')&&(*pcThisChar <= '9'))&&(BFoundAgeAlready != 2))
  443.                 {
  444.                     /* Found the age field, hopefully--this will keep being set until we find the last digit in the age */
  445.                     nTempAgeCol = nCount;
  446.                     BFoundAgeAlready = TRUE;
  447.                     
  448.                     pcThisChar++;
  449.                     nCount++;
  450.                 }
  451.                 else if (*pcThisChar != ' ')
  452.                 {
  453.                     /* Found the description, for sure */
  454.                     nTempPlusCol = nCount - 1;
  455.                     if (nTempPlusCol < 0) nTempPlusCol = 0;
  456.                     nTempDescCol = nCount;
  457.  
  458.                     pcThisChar -= 2;  /* move back to the left of the */
  459.                     nCount     -= 2;  /* first comment char AND the space */
  460.                     BDone = TRUE;    
  461.                 }
  462.                 else
  463.                 {    
  464.                     /* must be a space--continue onward */
  465.                     pcThisChar++;
  466.                     nCount++;
  467.                     
  468.                     /* If we were already doing the age, mark so as to not find another age! */
  469.                     if (BFoundAgeAlready == TRUE) BFoundAgeAlready = 2;    
  470.                 }
  471.                 break;
  472.         }
  473.     }
  474.     
  475.     /* Now we see if we've got something valid */
  476.     if (nState < 5) return(0);
  477.     
  478.     /* This in case there was no plus on this line! */
  479.     if (nTempPlusCol == -1) nTempPlusCol = nTempKCol + 1;
  480.     if (nTempDescCol == -1) nTempDescCol = (nTempPlusCol + (dataline[nTempPlusCol] != CHAR_NUL));
  481.     
  482.     /* Assign global vars */
  483.     nNameCol = nTempNameCol;
  484.     nDirCol  = nTempDirCol;
  485.     nKCol    = nTempKCol;
  486.     nPlusCol = nTempPlusCol;
  487.     nAgeCol  = nTempAgeCol;
  488.     nDescCol = nTempDescCol;
  489.     return(1);
  490. }
  491.     
  492.     
  493.     
  494.             
  495. int listviewgadgetClicked (VOID)
  496. {
  497. int i;
  498. struct Node *current = filelist->lh_Head;
  499. char *dataline = NULL;
  500.  
  501.  
  502.  for (i=0; i<lastcode; i++) current = current->ln_Succ;
  503.  
  504.  if (current != NULL)
  505.  {
  506.     /* Take it out of filelist */
  507.     AttachLists(FALSE);
  508.     TransferToSelected(current);
  509.     AttachLists(TRUE);
  510.  }
  511.  return(1);    
  512. }
  513.  
  514.  
  515.  
  516.  
  517.  
  518.  
  519.  
  520. int list2Clicked (VOID)
  521. {
  522.  /* This function will move a clicked item from the lower list to the upper one */
  523.  int i;
  524.  struct Node *current = getlist->lh_Head;
  525.  
  526.  for (i=0; i<lastcode; i++) current = current->ln_Succ;
  527.     
  528.  if (current != NULL)
  529.  {
  530.     AttachLists(FALSE);
  531.     TransferToFiles(current);
  532.     AttachLists(TRUE);
  533.  }
  534. }
  535.  
  536.  
  537.  
  538.  
  539.  
  540.  
  541. void TransferToSelected(struct Node *current)
  542. {
  543.  
  544.     if (isAminetParsable(current->ln_Name) == FALSE) return;  /* don't transfer what you cant understand */
  545.  
  546.     UpdateByteCount(current->ln_Name,1);
  547.     
  548.     /* Watch out for the nasty case where our search buffer just got removed */
  549.     if (search_current == current) 
  550.     {
  551.         if (search_current != filelist->lh_Head)    /* make sure we're not the first in the list */
  552.         {
  553.             search_current = search_current->ln_Pred;
  554.             search_index--;
  555.         }
  556.         else
  557.         {
  558.             search_current = search_current->ln_Succ;
  559.             search_index++;
  560.         }
  561.         
  562.         /* Check to see if we've walked off the front or back of the list */
  563.         /* If we have, default to the head of the list */
  564.         if (search_current == NULL) 
  565.         {
  566.             
  567.                 search_current = filelist->lh_Head;
  568.                 search_index = 0;
  569.         }
  570.     }
  571.  
  572.     Remove(current);
  573.     /* And insert it in getlist */
  574.     if ((nKeepSorted[1] == 1)&&(!noparse))
  575.     {
  576.         SmartAdd(getlist,current,nSortType[1]);
  577.     }
  578.     else
  579.     {
  580.         AddTail(getlist,current);
  581.     }
  582.     
  583.     filelist_length--;
  584.     getlist_length++;
  585.     
  586.     ChangeWindowTitle();
  587. }
  588.  
  589.  
  590.  
  591.  
  592. void TransferToFiles(struct Node *current)
  593. {
  594.     UpdateByteCount(current->ln_Name,-1);
  595.  
  596.     /* Take it out of getlist */
  597.     Remove(current);
  598.     current->ln_Succ = NULL;        /* Clear now invalid field */
  599.  
  600.     /* And insert it in filelist */
  601.      if ((nKeepSorted[0] == 1)&&(!noparse))
  602.      {    
  603.          SmartAdd(filelist,current,nSortType[0]);
  604.      }
  605.     else
  606.     {
  607.         AddTail(filelist,current);
  608.     }
  609.     
  610.     /* and that's it! */
  611.     filelist_length++;
  612.     getlist_length--;
  613.  
  614.     ChangeWindowTitle();
  615. }
  616.  
  617.  
  618.  
  619.  
  620.  
  621.  
  622.  
  623.  
  624. /* Returns file size, in weeks, of the given Aminet line--only
  625.    works if said file size is available, of course */
  626. int AminetFileAge(char *sString)
  627. {
  628.     int nTemp;
  629.     int nSum = 0;
  630.  
  631.     if (isAminetParsable(sString) == FALSE) return(0);
  632.  
  633.     /* New:  Assume that nAgeCol is the rightmost numeral of the number! */
  634.     nTemp = nAgeCol;
  635.     
  636.     if (nTemp < 0) return(-999);    /* there is no age! */
  637.     
  638.     /* no number? */
  639.     if ((sString[nTemp] < '0')||(sString[nTemp] > '9')) return(-999);
  640.  
  641.     /* go to front of string */
  642.     while ((nTemp > 0)&&(sString[nTemp] >= '0')&&(sString[nTemp] <= '9')) nTemp--;
  643.     nTemp++;
  644.     
  645.     while ((sString[nTemp] >= '0')&&(sString[nTemp] <= '9'))
  646.     {
  647.         nSum *= 10;
  648.         nSum += sString[nTemp] - '0';
  649.         nTemp++;
  650.     }
  651.     return(nSum);
  652. }
  653.  
  654.  
  655.  
  656. int AminetFileSize(char *sString)
  657. {
  658. /* Returns file size, in kilobytes, of the given Aminet line */
  659. int multiplier;
  660. int filesize = 0, wholenum;
  661. int outputlength = -1;
  662. int tenthofmultiplier = 0;
  663.  
  664.     if (isAminetParsable(sString) == FALSE) return(0);
  665.     
  666.     switch (sString[nKCol])
  667.     {
  668.         case 'M':
  669.             multiplier = 1024;   /* 1024 k in a M */
  670.             tenthofmultiplier = 102;
  671.             break;
  672.             
  673.         case 'K': 
  674.             multiplier = 1;     /* 1 k in a k */
  675.             break;
  676.         
  677.         case '?':
  678.             multiplier = 0;
  679.             break;
  680.             
  681.         default:
  682.             return(FALSE);
  683.     }
  684.     
  685.     if (sString[nKCol-2] == '.')        /* for when it's like:  3.5M */
  686.     {
  687.         /* figure out kilobytes */
  688.         wholenum = (int) (sString[nKCol-3] - '0');
  689.         
  690.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + (multiplier * wholenum);
  691.         
  692.         wholenum = (int) (sString[nKCol-1] - '0');
  693.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + (tenthofmultiplier * wholenum);
  694.     }
  695.     else
  696.     {
  697.         wholenum = (int) (sString[nKCol-3] - '0');
  698.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + (100 * multiplier * wholenum);
  699.  
  700.         wholenum = (int) (sString[nKCol-2] - '0');
  701.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + ( 10 * multiplier * wholenum);
  702.  
  703.         wholenum = (int) (sString[nKCol-1] - '0');
  704.         if ((wholenum >= 0)&&(wholenum <= 9)) filesize = filesize + (      multiplier * wholenum);
  705.     }
  706.     
  707.     return(filesize);
  708. }
  709.  
  710.  
  711.  
  712. void SmartAdd(struct List *thislist, struct Node *addme, int nThisSortType)
  713. {
  714. /* a simple add into the correct order of the list */
  715. struct Node *current, *past;
  716. char sBuffer1[43], sBuffer2[43];
  717.  
  718. current = thislist->lh_Head;
  719. past = NULL;
  720.  
  721. if ((addme == NULL)||(addme->ln_Name == NULL)) return();
  722.  
  723. while (current != NULL)            
  724. {
  725.     /* Only sort if this is an Aminet file line, or not an Aminet Sort */    
  726.     if ((current->ln_Name != NULL)&&(isAminetParsable(current->ln_Name)&&isAminetParsable(addme->ln_Name)))
  727.     {
  728.         switch(nThisSortType)
  729.         {
  730.             case SORTBYDIR:
  731.                 strncpy(sBuffer1,addme->ln_Name+nDirCol,DIRNAMESIZE);
  732.                 strncpy(sBuffer2,current->ln_Name+nDirCol,DIRNAMESIZE);
  733.                 if ((strchr(sBuffer1,'/') != NULL)&&
  734.                      (strchr(sBuffer2,'/') != NULL)&&
  735.                       (strncmp(sBuffer1,sBuffer2,DIRNAMESIZE) < 0))
  736.                 {
  737.                     Insert(thislist, addme, past);    /* and put it back in after current */
  738.                     return();
  739.                 }
  740.             break;
  741.         
  742.             case SORTBYDESC:
  743.                 if (strncmp(addme->ln_Name+nDescCol,current->ln_Name+nDescCol,DESCSIZE) < 0)
  744.                 {
  745.                     Insert(thislist, addme, past);    /* and put it back in after current */
  746.                     return();
  747.                 }
  748.             break;
  749.             
  750.             case SORTBYNAME:
  751.                 memset(sBuffer1,NUL,NAMESIZE);  /* sort sometimes goes into infinite loops if you don't have this??? */
  752.                 memset(sBuffer2,NUL,NAMESIZE);  /* It shouldn't, though, because strncpy terminates everything right? */
  753.                 strncpy(sBuffer1,addme->ln_Name+nNameCol,NAMESIZE);
  754.                 strncpy(sBuffer2,current->ln_Name+nNameCol,NAMESIZE);    
  755.                 if (strncmp(sBuffer1,sBuffer2,NAMESIZE) < 0)
  756.                 {
  757.                     Insert(thislist, addme, past);    /* and put it back in after current */        
  758.                     return();
  759.                 }
  760.             break;
  761.             
  762.             case SORTBYSIZE:
  763.                 if (AminetFileSize(addme->ln_Name) < AminetFileSize(current->ln_Name))
  764.                 {
  765.                     Insert(thislist, addme, past);    /* and put it back in after current */
  766.                     return();
  767.                 }
  768.                 
  769.             case SORTBYAGE:
  770.                 if (AminetFileAge(addme->ln_Name) < AminetFileAge(current->ln_Name))
  771.                 {
  772.                     Insert(thislist, addme, past);    /* and put it back in after current */
  773.                     return();
  774.                 }
  775.                 break;
  776.             }
  777.     }    
  778.     past = current;                /* step to next in list */
  779.     current = current->ln_Succ;
  780. }
  781.     
  782. AddTail(thislist,addme);        /* If we've got to the end without returning, add it to the end */
  783. return();
  784. }
  785.  
  786.  
  787.  
  788.  
  789.  
  790. int CompareByDir(struct Node *past, struct Node *current)
  791. {
  792.     static char sBuffer1[43], sBuffer2[43];  /* static to avoid re- and de-allocing */
  793.     
  794.     if (isAminetParsable(current->ln_Name) == FALSE) return(-999);     /* error! */
  795.          
  796.     if (sortcasesensitive == TRUE) 
  797.         return(strncmp(past->ln_Name+nDirCol,current->ln_Name+nDirCol,DIRNAMESIZE));  /* For Lists, > 0 = switch */
  798.  
  799.     /* case insensitive */    
  800.     strncpy(sBuffer1,past->ln_Name+nDirCol,DIRNAMESIZE);
  801.     strncpy(sBuffer2,current->ln_Name+nDirCol,DIRNAMESIZE);
  802.     UpperCase(sBuffer1);        /* not case sensitive */
  803.     UpperCase(sBuffer2);
  804.     
  805.     return(strncmp(sBuffer1,sBuffer2,DIRNAMESIZE));  /* For Lists, > 0 = switch */
  806. }
  807.  
  808.  
  809.  
  810.     
  811. int CompareByDesc(struct Node *past, struct Node *current)
  812. {
  813.     static char sBuffer1[43], sBuffer2[43];  /* static to avoid re- and de-allocing */
  814.  
  815.     /* Make sure the comment is ok! */
  816.     if (isAminetParsable(current->ln_Name) == FALSE) return(-999);     /* error! */
  817.     
  818.     if (sortcasesensitive == TRUE) return(strncmp(past->ln_Name+nDescCol,current->ln_Name+nDescCol,DESCSIZE));
  819.  
  820.     /* For Lists, > 0 = switch */
  821.     strncpy(sBuffer1,past->ln_Name+nDescCol,DESCSIZE);        /* copies to modify */
  822.     strncpy(sBuffer2,current->ln_Name+nDescCol,DESCSIZE);    
  823.     UpperCase(sBuffer1);        /* not case sensitive */
  824.     UpperCase(sBuffer2);
  825.     
  826.    return(strncmp(sBuffer1, sBuffer2,DESCSIZE));
  827. } 
  828.     
  829.  
  830.  
  831.     
  832.  
  833.  
  834. int CompareByName(struct Node *past, struct Node *current)
  835. {
  836.     static char sBuffer1[43], sBuffer2[43];  /* static to avoid re- and de-allocing */
  837.  
  838.     /* Make sure the comment is ok! */
  839.     if (isAminetParsable(current->ln_Name) == FALSE) return(-999);     /* error! */
  840.  
  841.     if (sortcasesensitive == TRUE) return(strncmp(past->ln_Name+nNameCol,current->ln_Name+nNameCol,NAMESIZE));
  842.     
  843.     /* case insensitive test below */    
  844.     strncpy(sBuffer1,past->ln_Name+nNameCol,NAMESIZE);
  845.     strncpy(sBuffer2,current->ln_Name+nNameCol,NAMESIZE);    
  846.     UpperCase(sBuffer1);
  847.     UpperCase(sBuffer2);
  848.     
  849.     return(strncmp(sBuffer1,sBuffer2,NAMESIZE));
  850. }
  851.  
  852.  
  853.  
  854.  
  855.  
  856. int CompareBySize(struct Node *past, struct Node *current) 
  857. {
  858.     return(AminetFileSize(past->ln_Name) - AminetFileSize(current->ln_Name));
  859. }
  860.  
  861.  
  862. int CompareByAge(struct Node *past, struct Node *current) 
  863. {
  864.     return(AminetFileAge(past->ln_Name) - AminetFileAge(current->ln_Name));
  865. }
  866.  
  867.  
  868. void SortList(struct List *thislist, int nThisSortType)
  869. {
  870.     static char sSortTypeString[40];
  871.     char *sSortWinString;
  872.     
  873.     SetMenuValues();
  874.  
  875.     pcWhatToAbort = "Sort";
  876.         
  877.     strcpy(sSortTypeString, "Sorting by \0");
  878.     
  879.     if (windowisopen) SetWindowTitles(mgetWnd, "Sorting--please be patient", (char *) ~0); 
  880.  
  881.     /* Generate Window title prompt */
  882.     switch(nThisSortType)
  883.     {
  884.         case SORTBYDIR:  strcat(sSortTypeString,"Directory: ");   break;
  885.         case SORTBYSIZE: strcat(sSortTypeString,"Size: ");      break;
  886.         case SORTBYDESC: strcat(sSortTypeString,"Description: "); break;
  887.         case SORTBYNAME: strcat(sSortTypeString,"FileName: ");    break;
  888.         case SORTBYAGE:  strcat(sSortTypeString,"Age: ");         break;
  889.         default:     strcat(sSortTypeString,"Unknown: ");      break;
  890.     }
  891.  
  892.     sSortWinString = strrchr(sSortTypeString,' ') + 1;        /* Where to write next */
  893.     sTreeWriteHere = sSortWinString;
  894.     szTickerString = sSortTypeString;
  895.             
  896.     if (thislist == NULL) return;
  897.     
  898.     /* Remove list from ListView if necessary  */
  899.      if (windowisopen)
  900.      {
  901.         AttachLists(FALSE);
  902.         SetWaitPointer(mgetWnd);
  903.     }
  904.  
  905.     switch (nSortAlgorithm)
  906.     {
  907.          case BUBBLESORT: BubbleSortList(thislist, nThisSortType, sSortWinString, sSortTypeString); break;
  908.          case TREESORT:   TreeSortList  (thislist, nThisSortType, sSortWinString, sSortTypeString); break;
  909.      }
  910.      
  911.     /* Replace list into ListView */
  912.     AttachLists(TRUE);
  913.     ClearWaitPointer(mgetWnd);
  914.     
  915.     ChangeWindowTitle();
  916.     SetMenuValues();
  917. }
  918.  
  919.  
  920.  
  921.  
  922.  
  923. int TreeSortUserCompare(struct Node *thisnode, struct Node *thatnode)
  924. {
  925.     int nResult;
  926.  
  927.     switch(nForTreeSortUseOnly)  /* using a global variable here stinks :( */
  928.     {
  929.         case SORTBYDIR:  nResult = CompareByDir (thisnode, thatnode); break;
  930.         case SORTBYNAME: nResult = CompareByName(thisnode, thatnode); break;
  931.         case SORTBYSIZE: nResult = CompareBySize(thisnode, thatnode); break;
  932.         case SORTBYDESC: nResult = CompareByDesc(thisnode, thatnode); break;
  933.         case SORTBYAGE:  nResult = CompareByAge (thisnode, thatnode); break;
  934.     }
  935.     if (nResult == 0) return(1);  /* default value can't be zero! */
  936.     return(nResult);
  937. }
  938.  
  939.  
  940.  
  941.  
  942. void TreeSortList(struct List *thislist, int nThisSortType, char *sSortWinString, char *sSortTypeString)    
  943. {
  944.     struct Node *CurrentNode = thislist->lh_Head;
  945.     tree *mytree = NULL;                                    
  946.  
  947.     /* make tree out of our list */
  948.     tree_init(&mytree);
  949.  
  950.     /* set global variables for TreeSortUserCompare and TransferNode's use */    
  951.     nForTreeSortUseOnly = nThisSortType;   /* Used by TreeSortUserCompare  */
  952.     lForTreeSortUseOnly = thislist;          /* Used by TransferNode         */
  953.     
  954.     lTreeTicker = 0;
  955.     lTreeSubTicker = 0;
  956.     
  957.     while (CurrentNode != NULL)
  958.     {        
  959.         if ((CurrentNode->ln_Succ != NULL) &&    /* <--This is necessary to avoid the "killer node" ??? */
  960.             (CurrentNode->ln_Name != NULL) &&
  961.             (*CurrentNode->ln_Name != cCommentChar))
  962.             tree_add(&mytree, TreeSortUserCompare, (char *) CurrentNode, DeleteNodeError);
  963.     
  964.         CurrentNode = CurrentNode->ln_Succ;        /* move down the list */
  965.         
  966.         if (CheckForUserAbort() == TRUE) CurrentNode = NULL;    /* kick out on abort */        
  967.     }
  968.     
  969.     /* traverse tree, inserting into new list */
  970.     /* nAbort now stays true only if both of the below are true */
  971.     if (tree_trav(&mytree,TransferNode) == FALSE)
  972.         MakeReq("Tree Sort Error","Warning:  Tree Sort failed; list may be incomplete", NULL);
  973.     
  974.     /* now clean up the tree -- since Nodes are still in a List, we don't want to delete them */
  975.      tree_mung(&mytree, DoNothing);
  976. }    
  977.  
  978.  
  979.  
  980. int CheckForUserAbort(void)
  981. {
  982.     static int nReturn;
  983.     static char szPrompt[20]="";
  984.     static struct IntuiMessage *imsg;
  985.     
  986.     if (mgetWnd == NULL) return(FALSE);
  987.     
  988.     while (imsg = GT_GetIMsg(mgetWnd->UserPort)) 
  989.     {
  990.         switch (imsg->Class)
  991.         {
  992.             case IDCMP_VANILLAKEY: case IDCMP_CLOSEWINDOW:
  993.                 if ((imsg->Code == CHAR_ESCAPE)||(imsg->Class == IDCMP_CLOSEWINDOW))
  994.                 {
  995.                     GT_ReplyIMsg(imsg);
  996.                     sprintf(szPrompt,"Abort the %s?",pcWhatToAbort);
  997.                     nReturn = (MakeReq(szPrompt,"GadMget Abort Request","Continue|Abort") == 0);
  998.                     if (mgetWnd != NULL) SetWaitPointer(mgetWnd);
  999.                     return(nReturn);
  1000.                 }
  1001.                 else GT_ReplyIMsg(imsg);
  1002.                 break;
  1003.                 
  1004.              case IDCMP_NEWSIZE: case IDCMP_REFRESHWINDOW:
  1005.                 HandlemgetIDCMP(imsg);    /* do window resize */
  1006.                  break;
  1007.  
  1008.             case IDCMP_MENUPICK:
  1009.                 SetMenuValues();    /* undo the damage */
  1010.                 GT_ReplyIMsg(imsg);
  1011.                 break;
  1012.                                      
  1013.              default:
  1014.                  GT_ReplyIMsg(imsg);
  1015.                  break;
  1016.         }
  1017.     }
  1018.     return(FALSE);
  1019. }
  1020.  
  1021.  
  1022. int DoNothing (struct Node *thisnode)
  1023. {
  1024.    /* and here is the magic code to .... do nothing! */
  1025.    return(0);
  1026. }
  1027.  
  1028.  
  1029.  
  1030.  
  1031.  
  1032. int TransferNode(struct Node *thisnode)
  1033. {    
  1034.     if (isAminetParsable(thisnode->ln_Name))
  1035.     {
  1036.         Remove(thisnode); 
  1037.         AddTail((struct List *) lForTreeSortUseOnly, thisnode); 
  1038.     }
  1039.     return(TRUE);
  1040. }
  1041.  
  1042.  
  1043.  
  1044.  
  1045.  
  1046.  
  1047. int PrintNodeData(struct Node *thisnode)
  1048. {
  1049.  
  1050.     if (thisnode == NULL) return(FALSE);
  1051.     if (thisnode->ln_Name == NULL) return(FALSE);
  1052.     
  1053.     printf("[%s]\n",thisnode->ln_Name);
  1054.     return(TRUE);
  1055. }
  1056.  
  1057.  
  1058.  
  1059.  
  1060.  
  1061.  
  1062. int DeleteNodeError(struct Node *thisnode)
  1063. {
  1064.     printf("tree_add tried to delete this node:\n");
  1065.     PrintNodeData(thisnode);
  1066. }
  1067.  
  1068.  
  1069.  
  1070.  
  1071.  
  1072.  
  1073. void BubbleSortList(struct List *thislist, int nThisSortType, char *sSortWinString, char *sSortTypeString)
  1074. {
  1075.    /* a simple swap-sort */
  1076.     int nSwappedThisPass = 1, nUpdateTitle = 0, nUpdateCount = 0;
  1077.     struct Node *current, *past;
  1078.  
  1079.     while (nSwappedThisPass > 0)
  1080.     {
  1081.         /* start a pass */
  1082.         past = thislist->lh_Head;
  1083.         if (past == NULL) return;
  1084.         
  1085.         current = past->ln_Succ;
  1086.         nSwappedThisPass = 0;        /* start with none recorded */
  1087.  
  1088.         while (current != NULL)            
  1089.         {
  1090.             /* Only sort if this is an Aminet file line, or not an Aminet Sort */    
  1091.             if ((current->ln_Name != NULL)&&(past->ln_Name != NULL)&&
  1092.                 (isAminetParsable(current->ln_Name)&&isAminetParsable(past->ln_Name)))
  1093.             {
  1094.                 if ((past->ln_Name != NULL)&&(*past->ln_Name != cCommentChar))
  1095.                 {
  1096.                     if ((nThisSortType == SORTBYDIR) &&(CompareByDir (past,current) > 0) ||
  1097.                         (nThisSortType == SORTBYSIZE)&&(CompareBySize(past,current) > 0) ||
  1098.                         (nThisSortType == SORTBYDESC)&&(CompareByDesc(past,current) > 0) ||
  1099.                         (nThisSortType == SORTBYNAME)&&(CompareByName(past,current) > 0))
  1100.                     {
  1101.                     /* Swap the two nodes */
  1102.                      Remove(past);
  1103.                      Insert(thislist, past, current);
  1104.                      nSwappedThisPass++;
  1105.                     }
  1106.                 }
  1107.             }    
  1108.             past = current;
  1109.             current = current->ln_Succ;
  1110.         }
  1111.         
  1112.         if (windowisopen)
  1113.         {
  1114.             sprintf(sSortWinString,"%i",nUpdateCount);
  1115.             SetWindowTitles(mgetWnd, sSortTypeString, (char *) ~0);
  1116.             nUpdateCount++; 
  1117.          }              
  1118.  
  1119.         if (CheckForUserAbort() == TRUE) nSwappedThisPass = 0;    /* kick out on abort */        
  1120.     }        
  1121.     return;
  1122. }
  1123.         
  1124.  
  1125. /* Returns the length of the first "word" in the string, i.e. number
  1126.    of letters before the space */        
  1127. int LengthOfWord(char *szString)
  1128. {
  1129.     char *pcTemp = szString;
  1130.     int nCount = 0;
  1131.  
  1132.     /* skip any leading spaces */
  1133.     while (*pcTemp == ' ') pcTemp++;
  1134.     
  1135.     /* Count chars in word */    
  1136.     while ((*pcTemp != CHAR_NUL)&&(*pcTemp != ' ')) 
  1137.     {
  1138.         nCount++;
  1139.         pcTemp++;
  1140.     }
  1141.     
  1142.     return(nCount);
  1143. }
  1144.  
  1145.  
  1146.  
  1147.  
  1148. int OutputList(struct List *thislist)
  1149. {
  1150.  #define LASTDIRBUFSIZE 30
  1151.  
  1152.  char *p;
  1153.  int k,l,z,next_bytes,putnameOK = 0,putcommandOK = 1; 
  1154.  int printed_bytes = maxoutputlinelength - 1, printreturnfirst = 0;
  1155.  char outname[MAXFILELINELENGTH],szLastDir[LASTDIRBUFSIZE];
  1156.  struct Node *current;
  1157.  
  1158.  memset(szLastDir,NUL,LASTDIRBUFSIZE);
  1159.  
  1160.  /* Get any readme files first, so user can browse them while d/l'ing the rest */
  1161.  if (getreadmes)
  1162.     {
  1163.     current = thislist->lh_Head;
  1164.      while (current != NULL)
  1165.      {
  1166.          /* watch out for empty nodes! */
  1167.         if (isAminetParsable(current->ln_Name))
  1168.         {
  1169.             z = strlen(current->ln_Name);
  1170.             /* Extra filtering code, borrowed from mgetlistviewclicked()... */
  1171.             if ((current->ln_Name[nNameCol] < '0')||(current->ln_Name [nNameCol] > 'z')) z = 0;
  1172.             if (current->ln_Name[nDirCol] < '0') z = 0;
  1173.             if ((filesflag == 0)&&(current->ln_Name[nPlusCol] != '+')) z = 0;
  1174.             /* end code from mgetlistviewclicked() ... */
  1175.         }
  1176.         else z=0;
  1177.         
  1178.         if (z>nDirCol)
  1179.         {
  1180.             k = LengthOfWord(¤t->ln_Name[nNameCol]);    /* length of filename */
  1181.             l = LengthOfWord(¤t->ln_Name[nDirCol]);   /* length of directory */
  1182.     
  1183.             if ((k<(nDirCol+1))&&(k>0)&&(l<12)&&(l>2))
  1184.             {
  1185.                 memset(outname,NUL,MAXFILELINELENGTH);
  1186.                 strncat(outname,¤t->ln_Name[nDirCol],l);
  1187.                 
  1188.                 /* Here we have the directory name--see if it's different, generate cd */
  1189.                 if ((current->ln_Name[nPlusCol] == '+')&&
  1190.                     (nocd == 0)&&
  1191.                     (simplepaths == 1)&&
  1192.                     (strncmp(szLastDir,outname,LASTDIRBUFSIZE) != 0)) 
  1193.                 {
  1194.                     memset(szLastDir,NUL,LASTDIRBUFSIZE);
  1195.                     GenerateCDCommand(&printreturnfirst, &printed_bytes, szLastDir, outname);
  1196.                     putnameOK = 1;
  1197.                     putcommandOK = 0;
  1198.                 }
  1199.                 
  1200.                 if (simplepaths == 1)
  1201.                 {    
  1202.                     /* remove path so it won't be printed again in the mget command */
  1203.                     memset(outname,NUL,sizeof(outname));
  1204.                 }
  1205.                 else
  1206.                 {
  1207.                     strncat(outname,"/",1);
  1208.                 }
  1209.                 
  1210.                 strncat(outname,¤t->ln_Name[nNameCol],k);
  1211.                 outname[79]=0;    /* just in case, we'll reterminate the string */            
  1212.             
  1213.                 if (current->ln_Name[nPlusCol] == '+')
  1214.                     {    
  1215.                     /* find the last '.' in outname, and change whatever's after it to 'readme'! */
  1216.                     p = strrchr(outname,'.');
  1217.                     
  1218.                     /* and if there is no "." ? */
  1219.                     if (p == NULL)
  1220.                     {
  1221.                         strcat(outname,".");
  1222.                         p = strrchr(outname,'.');
  1223.                     }
  1224.                     
  1225.                     strcpy(p+1,"readme");
  1226.                     
  1227.                     next_bytes = strlen(outname) + 1;    /* + 1 for the space */
  1228.                     if ((next_bytes>3)&&(next_bytes<39))
  1229.                         {
  1230.                         if ((putcommandOK == 1)&&(!nosplit)&&((printed_bytes + next_bytes) > maxoutputlinelength))
  1231.                             {
  1232.                             PrintCommandString(&printreturnfirst, &printed_bytes);            
  1233.                             putnameOK = 1;
  1234.                             }            
  1235.                         fprintf(fpOut,"%s ",outname);
  1236.                         printed_bytes = printed_bytes + next_bytes;
  1237.                         putcommandOK = 1;
  1238.                         }
  1239.                     }
  1240.                 }
  1241.             }
  1242.         current = current->ln_Succ;    
  1243.         }
  1244.     }        
  1245.  
  1246.  if (filesflag)
  1247.  {    
  1248.      current = thislist->lh_Head;    
  1249.     while (current != NULL)
  1250.     {
  1251.          /* watch out for empty nodes! */
  1252.         if (isAminetParsable(current->ln_Name))
  1253.         {
  1254.             z = strlen(current->ln_Name);
  1255.             /* Extra filtering code, borrowed from mgetlistviewclicked()... */
  1256.             if ((current->ln_Name[nNameCol] < '0')||(current->ln_Name [nNameCol] > 'z')) z = 0;
  1257.             if ((filesflag == 0)&&(current->ln_Name[nPlusCol] != '+')) z = 0;
  1258.             /* end code from mgetlistviewclicked() ... */
  1259.         }
  1260.         else z=0;
  1261.  
  1262.         if (z>nDirCol)
  1263.         {
  1264.             k = LengthOfWord(¤t->ln_Name[nNameCol]);    /* length of filename */
  1265.             l = LengthOfWord(¤t->ln_Name[nDirCol]);   /* length of directory */
  1266.  
  1267.             if ((k<(nDirCol+1))&&(k>0)&&(l<12)&&(l>2))
  1268.             {
  1269.                 memset(outname,NUL,MAXFILELINELENGTH);
  1270.                 strncat(outname,¤t->ln_Name[nDirCol],l);
  1271.  
  1272.                 /* Here we have the directory name--see if it's different, generate cd */
  1273.                 if ((nocd == 0)&&
  1274.                     (simplepaths == 1)&&
  1275.                     (strncmp(szLastDir,outname,LASTDIRBUFSIZE) != 0)) 
  1276.                 {
  1277.                     memset(szLastDir,NUL,LASTDIRBUFSIZE);
  1278.                     GenerateCDCommand(&printreturnfirst, &printed_bytes, szLastDir, outname);
  1279.                     putcommandOK = 0;
  1280.                     putnameOK = 1;
  1281.                 }
  1282.                 
  1283.                 if (simplepaths == 1)
  1284.                 {    
  1285.                     /* remove path so it won't be printed again in the mget command */
  1286.                     memset(outname,NUL,sizeof(outname));
  1287.                 }
  1288.                 else
  1289.                 {
  1290.                     strncat(outname,"/",1);
  1291.                 }
  1292.                 
  1293.                 
  1294.                 strncat(outname,¤t->ln_Name[nNameCol],k);
  1295.                 outname[79]=0;    /* just in case, we'll reterminate the string */            
  1296.                 if (filesflag)
  1297.                 {    
  1298.                     next_bytes = strlen(outname) + 1;    /* + 1 for the space */
  1299.                     if ((next_bytes>3)&&(next_bytes<33))
  1300.                     {
  1301.                         if ((putcommandOK == 1)&&(!nosplit)&&((printed_bytes + next_bytes) > maxoutputlinelength))
  1302.                         {
  1303.                             PrintCommandString(&printreturnfirst, &printed_bytes);    
  1304.                             putnameOK = 1;
  1305.                         }            
  1306.                         fprintf(fpOut,"%s ",outname);
  1307.                         putcommandOK = 1;
  1308.                         printed_bytes = printed_bytes + next_bytes;
  1309.                     }
  1310.                 }
  1311.             }
  1312.         }    
  1313.     current = current->ln_Succ;    
  1314.     }
  1315.  }
  1316. return(1);
  1317. }
  1318.  
  1319.  
  1320.  
  1321.  
  1322. void PrintCommandString(int *printreturnfirst, int *printed_bytes)
  1323. {
  1324.     if (*printreturnfirst) fprintf(fpOut,sEndOfLineString); 
  1325.     *printreturnfirst = 1;
  1326.         
  1327.     if (nocommand) 
  1328.     {
  1329.         *printed_bytes = 0;
  1330.     }
  1331.     else
  1332.     {
  1333.         fprintf(fpOut,"%s",szCommandString);
  1334.         *printreturnfirst = 1;
  1335.         *printed_bytes = strlen(szCommandString) + 1;    /* reset counter for next batch */
  1336.     }
  1337.     return;
  1338. }
  1339.  
  1340.  
  1341.  
  1342.  
  1343. void GenerateCDCommand(int *printreturnfirst, int *printed_bytes, char *szLastDir, char *outname)
  1344. {
  1345.     if (*printreturnfirst) fprintf(fpOut,sEndOfLineString);
  1346.     fprintf(fpOut,"cd ");
  1347.                 
  1348.     /* On the first item, we will be starting at the aminet root
  1349.        directory, so we won't need to print the ../.. .  After that,
  1350.         though, we will.  printreturnfirst serves nicely to tell
  1351.         whether or not we're in the first iteration. */   
  1352.     
  1353.     if (*printreturnfirst == 1) fprintf(fpOut,sAminetPathString);
  1354.             
  1355.     fprintf(fpOut,"%s",outname);
  1356.     *printreturnfirst = 1;
  1357.     PrintCommandString(printreturnfirst, printed_bytes);
  1358.  
  1359.     /* update buffer */    
  1360.     strncpy(szLastDir,outname,30);    
  1361.  
  1362.     return;
  1363. }            
  1364.  
  1365.  
  1366.  
  1367. int RawOutputList(struct List *thislist)
  1368. {
  1369.  struct Node *current = thislist->lh_Head;
  1370.  int minlinelength = 1;
  1371.  
  1372.  if (keepblanklines == 1) minlinelength = 0;
  1373.  
  1374.  if (mgetWnd != NULL) SetWaitPointer(mgetWnd);
  1375.  
  1376.       
  1377.  while (current != NULL)
  1378.  {    
  1379.     if ((current->ln_Name != NULL)&&(current->ln_Name[0] < 128)&&(strlen(current->ln_Name) >= minlinelength))
  1380.     {
  1381.         if (current->ln_Name[0] < minlinelength)     /* was 14? */
  1382.             fprintf(fpOut,"\n",current->ln_Name);
  1383.         else    fprintf(fpOut,"%.300s\n",current->ln_Name);
  1384.     }
  1385.     current = current->ln_Succ;
  1386.  }
  1387.  
  1388.  ClearWaitPointer(mgetWnd);
  1389.  
  1390.  return(1);
  1391. }
  1392.  
  1393.  
  1394.  
  1395.  
  1396.  
  1397.  
  1398.  
  1399.  
  1400.  
  1401. int MakeReq(char *sText, char *sTitle, char *sGadgets)
  1402. {
  1403.     struct EasyStruct myreq;
  1404.     LONG number = 0L;
  1405.     int nResult;
  1406.     
  1407.     if (sTitle == NULL) sTitle = "GadMGet Error";
  1408.     if (sText == NULL) sText = "A nasty error happened!";
  1409.     if (sGadgets == NULL) sGadgets = "OK";
  1410.     
  1411.     myreq.es_TextFormat   = sText;
  1412.     myreq.es_Title        = sTitle;
  1413.     myreq.es_GadgetFormat = sGadgets;
  1414.     
  1415.     SetWaitPointer(mgetWnd);
  1416.     nResult = EasyRequest(mgetWnd, &myreq, NULL, NULL, number);
  1417.     ClearWaitPointer(mgetWnd);
  1418.     return(nResult);
  1419. }
  1420.  
  1421.  
  1422. int mgettreesort (VOID)
  1423. {
  1424.     nSortAlgorithm = TREESORT;
  1425.     SetMenuValues();
  1426. }
  1427.  
  1428. int mgetbubblesort (VOID)
  1429. {
  1430.     nSortAlgorithm = BUBBLESORT;
  1431.     SetMenuValues();
  1432. }    
  1433.  
  1434. int mgetsortcase (VOID)
  1435. {
  1436.     sortcasesensitive = Not[sortcasesensitive];
  1437.     if (nKeepSorted[0] == 1) SortList(filelist,nSortType[0]);
  1438.     if (nKeepSorted[1] == 1) SortList(getlist, nSortType[1]);
  1439.     SetMenuValues();
  1440. }
  1441.  
  1442.  
  1443.  
  1444.  
  1445.  
  1446.  
  1447.  
  1448.  
  1449. int mgetabout (VOID)
  1450. {
  1451.     char sAboutText[100];
  1452.  
  1453.     sprintf(sAboutText,"    %s\n\n  by Jeremy Friesner\n  jfriesne@ucsd.edu\n\nCompiled: %s",
  1454.             pnamestring, __DATE__);
  1455.     MakeReq(sAboutText,"About GadMGet","Hey, Cool!");
  1456.         
  1457.     #ifdef OLD
  1458.     strcpy(sAboutText,pnamestring);
  1459.     strcat(sAboutText,"\n\nby Jeremy Friesner\njfriesne@ucsd.edu\n");
  1460.     MakeReq(sAboutText,"About GadMGet","Hey, Cool!");
  1461.     #endif 
  1462.     
  1463.     return(1);
  1464. }
  1465.  
  1466.  
  1467.  
  1468.  
  1469.  
  1470.  
  1471.  
  1472.  
  1473. int mgetquit (VOID)
  1474. {
  1475.     done=TRUE;
  1476. }
  1477.  
  1478.  
  1479.  
  1480.  
  1481. int mgetmultiselect(VOID)
  1482. {
  1483. int lin, nSortAtEnd = FALSE;
  1484. struct Node *select_current = filelist->lh_Head, *select_next = NULL;
  1485. char sUpperBuffer[MAXFILELINELENGTH],sUpperSearchString[MAXFILELINELENGTH];
  1486.  
  1487. requesttype = SELECT_REQUESTTYPE;       /* This is a HORRIBLE way to program, but I don't want  */
  1488. lin = mgetfind();                                /* to try to change the parameters since it might screw */
  1489. requesttype = FIND_REQUESTTYPE;            /* up the mget_listview2 functions...                        */
  1490.  
  1491.  if (lin == TRUE) 
  1492.  {
  1493.     SetWaitPointer(mgetWnd);
  1494.     AttachLists(FALSE);
  1495.             
  1496.     if (searchcasesensitive)    
  1497.     {            
  1498.         while (select_current != NULL)
  1499.         {
  1500.             if ((nKeepSorted[1] == TRUE)&&(getlist_length > 240))
  1501.             {
  1502.                   nSortAtEnd = TRUE;                        /* remember to sort when done */
  1503.                   nKeepSorted[1] = FALSE;
  1504.             }       
  1505.  
  1506.             if ((select_current->ln_Name != NULL)&&
  1507.                 (strstr(select_current->ln_Name,sMultiSelect) != 0))
  1508.             {
  1509.                 select_next = select_current->ln_Succ;
  1510.                 TransferToSelected(select_current);
  1511.                 select_current = select_next;
  1512.             }
  1513.             else
  1514.             {
  1515.                 select_current = select_current->ln_Succ; 
  1516.             }
  1517.         }
  1518.     }
  1519.     else
  1520.     {
  1521.         strncpy(sUpperSearchString,sMultiSelect,sizeof(sUpperSearchString));
  1522.         UpperCase(sUpperSearchString);
  1523.         while (select_current != NULL)
  1524.         {
  1525.             if ((nKeepSorted[1] == TRUE)&&(getlist_length > 240))
  1526.             {
  1527.                   nSortAtEnd = TRUE;                        /* remember to sort when done */
  1528.                   nKeepSorted[1] = FALSE;
  1529.             }       
  1530.  
  1531.             if (select_current->ln_Name != NULL)
  1532.             {
  1533.                 strncpy(sUpperBuffer,select_current->ln_Name,sizeof(sUpperBuffer)-1);
  1534.                 UpperCase(sUpperBuffer);
  1535.  
  1536.                 if (strstr(sUpperBuffer,sUpperSearchString) != 0)
  1537.                 {
  1538.                     select_next = select_current->ln_Succ;
  1539.                     TransferToSelected(select_current);
  1540.                     select_current = select_next;
  1541.                 }
  1542.                 else
  1543.                 {
  1544.                     select_current = select_current->ln_Succ; 
  1545.                 }
  1546.             }
  1547.             else
  1548.             {
  1549.                     select_current = select_current->ln_Succ; 
  1550.             }
  1551.         }
  1552.     }
  1553.  
  1554.  if (nSortAtEnd == TRUE)
  1555.  {
  1556.      mgetgetkeep();        /* Sort files now, at the end */
  1557.  }
  1558.  
  1559.  AttachLists(TRUE);
  1560.  ChangeWindowTitle();
  1561.  ClearWaitPointer(mgetWnd);
  1562.  }
  1563. }
  1564.  
  1565.  
  1566.  
  1567.  
  1568.  
  1569. int mgetmultideselect(VOID)
  1570. {
  1571. int lin, nSortAtEnd = FALSE;
  1572. struct Node *select_current = getlist->lh_Head, *select_next = NULL;
  1573. char sUpperBuffer[MAXFILELINELENGTH], sUpperSearchString[MAXFILELINELENGTH];
  1574.  
  1575. requesttype = DESELECT_REQUESTTYPE;       /* This is a HORRIBLE way to program, but I don't want  */
  1576. lin = mgetfind();               /* to try to change the parameters since it might screw */
  1577. requesttype = FIND_REQUESTTYPE;           /* up the mget_listview2 functions...           */
  1578.  
  1579. if (lin == TRUE) 
  1580.  {
  1581.      SetWaitPointer(mgetWnd);
  1582.     AttachLists(FALSE);
  1583.     
  1584.     if (searchcasesensitive)    
  1585.     {
  1586.         while (select_current != NULL)
  1587.         {
  1588.            if ((nKeepSorted[0] == TRUE)&&(filelist_length > 240))
  1589.             {
  1590.                  nSortAtEnd = TRUE;                        /* remember to sort when done */
  1591.                   nKeepSorted[0] = FALSE;
  1592.             }
  1593.  
  1594.             if ((select_current->ln_Name != NULL)&&
  1595.                 (strstr(select_current->ln_Name,sMultiSelect) != 0))
  1596.             {
  1597.                 select_next = select_current->ln_Succ;
  1598.                 TransferToFiles(select_current);
  1599.                 select_current = select_next;
  1600.             }
  1601.             else
  1602.             {
  1603.                 select_current = select_current->ln_Succ; 
  1604.             }
  1605.         }
  1606.     }
  1607.     else
  1608.     {
  1609.         strncpy(sUpperSearchString,sMultiSelect,sizeof(sUpperSearchString));
  1610.         UpperCase(sUpperSearchString);
  1611.         while (select_current != NULL)
  1612.         {
  1613.            if ((nKeepSorted[0] == TRUE)&&(filelist_length > 240))
  1614.             {
  1615.                  nSortAtEnd = TRUE;                        /* remember to sort when done */
  1616.                   nKeepSorted[0] = FALSE;
  1617.             }
  1618.  
  1619.             if (select_current->ln_Name != NULL)
  1620.             {
  1621.                 strncpy(sUpperBuffer,select_current->ln_Name,sizeof(sUpperBuffer)-1);
  1622.                 UpperCase(sUpperBuffer);
  1623.  
  1624.                 if (strstr(sUpperBuffer,sUpperSearchString) != 0)
  1625.                 {
  1626.                     select_next = select_current->ln_Succ;
  1627.                     TransferToFiles(select_current);
  1628.                     select_current = select_next;
  1629.                 }
  1630.                 else
  1631.                 {
  1632.                     select_current = select_current->ln_Succ; 
  1633.                 }
  1634.             }
  1635.             else
  1636.             {
  1637.                     select_current = select_current->ln_Succ; 
  1638.             }
  1639.         
  1640.         }
  1641.     }
  1642.  
  1643.  if (nSortAtEnd == TRUE)
  1644.  {
  1645.      mgetfileskeep();        /* Sort files now, at the end */
  1646.  }
  1647.  
  1648.  AttachLists(TRUE);
  1649.  ChangeWindowTitle();
  1650.  ClearWaitPointer(mgetWnd);
  1651.  }
  1652. }
  1653.  
  1654.  
  1655.  
  1656.  
  1657.  
  1658. int mgetcase (VOID)
  1659. {
  1660. searchcasesensitive = Not[searchcasesensitive];
  1661. SetMenuValues();
  1662. }
  1663.  
  1664.  
  1665.  
  1666.  
  1667. int mgetCD (VOID)
  1668. {
  1669. simplepaths = Not[simplepaths];
  1670. SetMenuValues();
  1671. }
  1672.  
  1673.  
  1674.  
  1675.  
  1676.  
  1677.  
  1678. int mgetfindtop (VOID)
  1679. {
  1680.     mgetfind_findtype = SEARCHTYPE_TOP;
  1681.     mgetfind();
  1682.     mgetfind_findtype = SEARCHTYPE_FORWARD;
  1683.     return(TRUE);
  1684. }
  1685.  
  1686.  
  1687.  
  1688. int mgetfindbottom (VOID)
  1689. {
  1690.     mgetfind_findtype = SEARCHTYPE_BOTTOM;
  1691.     mgetfind();
  1692.     mgetfind_findtype = SEARCHTYPE_FORWARD;
  1693.     return(TRUE);
  1694. }
  1695.  
  1696.  
  1697. int mgetfindback (VOID)
  1698. {
  1699.     mgetfind_findtype = SEARCHTYPE_BACKWARD;
  1700.     mgetfind();
  1701.     mgetfind_findtype = SEARCHTYPE_FORWARD;
  1702.     return(TRUE);
  1703. }
  1704.  
  1705.  
  1706. int mgetfind (VOID)
  1707. {
  1708. ULONG winsig, signals;
  1709. int done = 0, found = 0, index = -1;
  1710. int fwindowwidth = 450, fwindowheight = 35 + Scr->RastPort.TxHeight;
  1711. int fwindowleft = (mgetLeft + (windowwidth/2) - (fwindowwidth/2));
  1712. int fwindowtop  = (mgetTop  + (windowheight/2)- (fwindowheight/2));
  1713. int WindowHeightLines = nTopListHeight/(listfont.ta_YSize);
  1714. struct NewGadget stringGad;
  1715. struct IntuiMessage *imsg;
  1716. struct Gadget *newgad = NULL;
  1717. char numstring[100], *ss = searchstring, sTempOutString[300];
  1718. char *wp = NULL,windowtitlestring0[] = "Search Window", 
  1719.                 windowtitlestring1[] = "Line Length Window",
  1720.                 windowtitlestring2[] = "Output File Change Window",
  1721.                 windowtitlestring3[] = "Select Multiple Items Window",
  1722.                 windowtitlestring4[] = "Deselect Multiple Items Window";
  1723. FILE *fpTemp = NULL;
  1724.  
  1725. findvi  = GetVisualInfo(Scr, TAG_END);
  1726. if (findvi == NULL) return(0);
  1727. if (findwindow != NULL) return(0);
  1728.  
  1729.  
  1730. if (fwindowleft < 0) fwindowleft = mgetLeft;
  1731. if (fwindowheight < 0) fwindowtop = mgetTop;
  1732.  
  1733.  newgad = CreateContext(&findgadlist);
  1734.  if (newgad == 0)
  1735.     {
  1736.     MakeReq("Couldn't create findwindow gad context!\n",NULL,NULL);
  1737.     return(0);
  1738.     }
  1739.  
  1740.  if (newgad == NULL) return(0);
  1741.  
  1742.  stringGad.ng_TextAttr     = &topaz8;    /* Cant figure out how to get system default into a TextAttr!  No name string available! */
  1743.  stringGad.ng_VisualInfo = findvi;
  1744.  stringGad.ng_LeftEdge     = 5;
  1745.  stringGad.ng_TopEdge    = 18 + Scr->RastPort.TxHeight;
  1746.  stringGad.ng_Width     = (fwindowwidth-10);
  1747.  stringGad.ng_Height     = 13;
  1748.  stringGad.ng_GadgetText = "Please enter search string.";
  1749.  stringGad.ng_GadgetID     = 35;    
  1750.  stringGad.ng_Flags     = PLACETEXT_ABOVE;
  1751.  
  1752.  switch (requesttype)
  1753.  {
  1754.      case FIND_REQUESTTYPE:
  1755.         wp = windowtitlestring0;
  1756.    break;
  1757.  
  1758.    case LINELENGTH_REQUESTTYPE:
  1759.          wp = windowtitlestring1;
  1760.          stringGad.ng_GadgetText = "Please enter new maximum line length.";
  1761.          sprintf(numstring,"%i\0",maxoutputlinelength);    
  1762.          ss = numstring;
  1763.    break;
  1764.    
  1765.    case OUTPUTFILE_REQUESTTYPE:
  1766.          wp = windowtitlestring2;
  1767.          stringGad.ng_GadgetText = "Please enter new output file path/device.";
  1768.          sprintf(numstring,"%s",sOutFileName);
  1769.          strncpy(sTempOutString,sOutFileName,sizeof(sTempOutString));
  1770.          ss = sTempOutString;
  1771.    break;
  1772.    
  1773.    case SELECT_REQUESTTYPE:
  1774.        wp = windowtitlestring3;
  1775.        stringGad.ng_GadgetText = "Please enter key string to select files with.";
  1776.        sprintf(numstring,"%s",sMultiSelect);
  1777.          strncpy(sTempOutString,sMultiSelect,sizeof(sTempOutString));
  1778.          ss = sTempOutString;       
  1779.    break;
  1780.    
  1781.    case DESELECT_REQUESTTYPE:
  1782.        wp = windowtitlestring4;
  1783.        stringGad.ng_GadgetText = "Please enter key string to deselect files with.";
  1784.        sprintf(numstring,"%s",sMultiSelect);
  1785.        strncpy(sTempOutString,sMultiSelect,sizeof(sTempOutString));
  1786.        ss = sTempOutString;
  1787.       break;
  1788.  }
  1789.  
  1790.  
  1791.  newgad = CreateGadget(STRING_KIND, newgad, &stringGad, 
  1792.               GTST_String, ss, 
  1793.               STRINGA_Justification, GACT_STRINGCENTER, 
  1794.               GA_Immediate, TRUE,
  1795.               TAG_END);  
  1796.  
  1797.  if (newgad == NULL) 
  1798.  {
  1799.     FreeGadgets(findgadlist);
  1800.     FreeVisualInfo(findvi);
  1801.     return(0);
  1802.  }
  1803.  
  1804.  if (GadToolsBase->lib_Version == 37)
  1805.  {
  1806.     /* Only do it the "illegal" way under v37.  GA_Immediate in the CreateGadget
  1807.        line, above, won't work under v37 but will on later releases. */
  1808.     newgad->Activation |= GACT_IMMEDIATE; 
  1809.  }    
  1810.  
  1811.  switch (screentype)
  1812.  {
  1813.     case USE_PUBSCREEN:
  1814.         findwindow = OpenWindowTags(NULL,
  1815.             WA_Left,        fwindowleft,
  1816.             WA_Top,        fwindowtop,
  1817.             WA_Width,         fwindowwidth,
  1818.             WA_Height,    fwindowheight,
  1819.             WA_PubScreen,    Scr,
  1820.             WA_PubScreenFallBack, TRUE,
  1821.             WA_IDCMP,        STRINGIDCMP|IDCMP_CLOSEWINDOW|
  1822.                         IDCMP_REFRESHWINDOW|IDCMP_ACTIVEWINDOW,
  1823.             WA_Flags,        WFLG_DRAGBAR|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  1824.             WA_Gadgets,    findgadlist,
  1825.             WA_Title,         wp,
  1826.             WA_ScreenTitle,    pnamestring,
  1827.             TAG_DONE );
  1828.     break;
  1829.     
  1830.     case USE_CUSTOMSCREEN:
  1831.         findwindow = OpenWindowTags(NULL,
  1832.             WA_Left,        fwindowleft,
  1833.             WA_Top,        fwindowtop,
  1834.             WA_Width,         fwindowwidth,
  1835.             WA_Height,    fwindowheight,
  1836.             WA_CustomScreen, Scr,
  1837.             WA_IDCMP,        STRINGIDCMP|IDCMP_CLOSEWINDOW|
  1838.                         IDCMP_REFRESHWINDOW|IDCMP_ACTIVEWINDOW,
  1839.             WA_Flags,        WFLG_DRAGBAR|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  1840.             WA_Gadgets,    findgadlist,
  1841.             WA_Title,         wp,
  1842.             WA_ScreenTitle,    pnamestring,
  1843.             WA_CustomScreen,    Scr,
  1844.             TAG_DONE );
  1845.     break;
  1846.  
  1847.     case USE_WBSCREEN:
  1848.         findwindow = OpenWindowTags(NULL,
  1849.             WA_Left,        fwindowleft,
  1850.             WA_Top,        fwindowtop,
  1851.             WA_Width,         fwindowwidth,
  1852.             WA_Height,    fwindowheight,
  1853.             WA_IDCMP,        STRINGIDCMP|IDCMP_CLOSEWINDOW|
  1854.                         IDCMP_REFRESHWINDOW|IDCMP_ACTIVEWINDOW,
  1855.             WA_Flags,        WFLG_DRAGBAR|WFLG_CLOSEGADGET|WFLG_SMART_REFRESH|WFLG_ACTIVATE,
  1856.             WA_Gadgets,    findgadlist,
  1857.             WA_Title,         wp,
  1858.             WA_ScreenTitle,    pnamestring,
  1859.             TAG_DONE );
  1860.     break;
  1861.     }
  1862.  
  1863. if (findwindow == NULL) return(0);
  1864. GT_RefreshWindow(findwindow, NULL); 
  1865.  
  1866. SetWindowTitles(mgetWnd, "MGet window inactive--close daughter window to continue", (char *) ~0); 
  1867. SetWaitPointer(mgetWnd);
  1868.  
  1869. winsig = 1 << findwindow->UserPort->mp_SigBit;
  1870.  
  1871.  while (!done)
  1872.  {
  1873.     signals = Wait(winsig);
  1874.     if (signals&winsig)
  1875.     {
  1876.         while ((!done) && (imsg = GT_GetIMsg(findwindow->UserPort)))
  1877.         {
  1878.             
  1879.             switch(imsg->Class)
  1880.             {            
  1881.                 case IDCMP_ACTIVEWINDOW:
  1882.                     ActivateGadget(newgad,findwindow,NULL);
  1883.                     break;
  1884.                         
  1885.                 case IDCMP_GADGETUP:
  1886.                     strncpy(ss,((struct StringInfo*)newgad->SpecialInfo)->Buffer,sizeof(searchstring));
  1887.                     done = 1;
  1888.                     break;
  1889.         
  1890.                 case IDCMP_CLOSEWINDOW:
  1891.                     done = 2;
  1892.                     break;
  1893.                     
  1894.                 case IDCMP_REFRESHWINDOW:
  1895.                     GT_BeginRefresh(findwindow);
  1896.                     GT_EndRefresh(findwindow, TRUE);
  1897.                     break;
  1898.             }
  1899.             GT_ReplyIMsg(imsg);
  1900.         }
  1901.     }
  1902.  }
  1903.     
  1904. CloseWindow(findwindow);
  1905. FreeGadgets(findgadlist);
  1906. FreeVisualInfo(findvi); 
  1907. findwindow = NULL;
  1908.  
  1909. ClearWaitPointer(mgetWnd);
  1910. ChangeWindowTitle();  /* just in case */
  1911.  
  1912.  if ((requesttype == SELECT_REQUESTTYPE)||(requesttype == DESELECT_REQUESTTYPE))
  1913.  {
  1914.      if (strlen(sTempOutString) == 0) return(FALSE);  /* empty string = abort, don't move any items */
  1915.     strncpy(sMultiSelect,sTempOutString,sizeof(sMultiSelect));
  1916.      ChangeWindowTitle();
  1917.      return(TRUE);
  1918.  }
  1919.  
  1920.  if (requesttype == LINELENGTH_REQUESTTYPE) 
  1921.  {
  1922.         ChangeWindowTitle();    
  1923.         return(atoi(ss));
  1924.  }
  1925.  
  1926.  if (requesttype == OUTPUTFILE_REQUESTTYPE)
  1927.  {
  1928.     if (strlen(sTempOutString) == 0)
  1929.     {
  1930.         if (BStartedFromWB == FALSE)
  1931.         {
  1932.             fpOut = stdout;
  1933.             *sOutFileName = CHAR_NUL;    /* blank out filename string */
  1934.         }
  1935.         else
  1936.         {
  1937.             strncpy(sTempOutString,"ram:GadMget.output",sizeof(sOutFileName));
  1938.         }
  1939.     }
  1940.     else
  1941.     {
  1942.         fpTemp = fopen(sTempOutString,"w");
  1943.         if (fpTemp == NULL)
  1944.         {
  1945.             MakeReq("Couldn't open output file!\n",NULL,NULL);
  1946.         }
  1947.         else
  1948.         {
  1949.             fpOut = fpTemp;
  1950.             strncpy(sOutFileName,sTempOutString,sizeof(sOutFileName));
  1951.             fclose(fpTemp);
  1952.         }
  1953.     }
  1954.     ChangeWindowTitle();
  1955.     return(0);
  1956.  }
  1957.     
  1958.  if ((done == 2)||(strlen(searchstring) == 0))
  1959.  {
  1960.     ChangeWindowTitle();
  1961.     return(0);    /* can use searchstring now instead of ss */
  1962.  }            /* because we're no longer worried about the nums */
  1963.  
  1964.  /* Now find it in the filelist */
  1965.  index = SearchList(searchstring,mgetfind_findtype);
  1966.  if (index == -1) DisplayBeep(Scr); else findgadgoto(index,3);
  1967.  return(1);
  1968. }
  1969.  
  1970.  
  1971.  
  1972.  
  1973.  
  1974.  
  1975. int mgetfindnext (VOID)
  1976. {
  1977. int next_index;
  1978.  
  1979. /* bump to next node */
  1980. next_index = SearchList(searchstring,SEARCHTYPE_NEXT);
  1981. if (next_index == -1) DisplayBeep(Scr); else findgadgoto(next_index,2);
  1982.  
  1983. return(TRUE);
  1984. }
  1985.  
  1986.  
  1987.  
  1988. int mgetfindprevious (VOID)
  1989. {
  1990. int prev_index;
  1991.  
  1992. /* bump to previous node */
  1993. prev_index = SearchList(searchstring,SEARCHTYPE_PREVIOUS);
  1994. if (prev_index == -1) DisplayBeep(Scr); else findgadgoto(prev_index,2);
  1995.  
  1996. return(TRUE);
  1997. }
  1998.  
  1999. int mgetfindcurrent (VOID)
  2000. {
  2001. if ((search_index == -1)||(search_current == NULL)) DisplayBeep(Scr); else findgadgoto(search_index,2);
  2002.  
  2003. return(TRUE);
  2004. }
  2005.  
  2006.  
  2007. int mgetfilesbydir (void)
  2008. {
  2009. nSortType[0] = SORTBYDIR;
  2010.  
  2011. SortList(filelist,nSortType[0]);
  2012. }
  2013.  
  2014.  
  2015. int mgetfilesbysize (void)
  2016. {
  2017. nSortType[0] = SORTBYSIZE;
  2018.  
  2019. SortList(filelist,nSortType[0]);
  2020. }
  2021.  
  2022.  
  2023. int mgetfilesbyname (void)
  2024. {
  2025. nSortType[0] = SORTBYNAME;
  2026.  
  2027. SortList(filelist,nSortType[0]);
  2028. }
  2029.  
  2030.  
  2031. int mgetfilesbydesc (void)
  2032. {
  2033. nSortType[0] = SORTBYDESC;
  2034.  
  2035. SortList(filelist,nSortType[0]);
  2036. }
  2037.  
  2038. int mgetfilesbyage (void)
  2039. {
  2040. nSortType[0] = SORTBYAGE;
  2041.  
  2042. SortList(filelist,nSortType[0]);
  2043. }
  2044.  
  2045.  
  2046. int mgetfileskeep (void)
  2047. {
  2048. if (nKeepSorted[0] == 1) 
  2049.     {
  2050.         nKeepSorted[0] = 0;
  2051.     }
  2052.     else
  2053.     {
  2054.         nKeepSorted[0] = 1;
  2055.         SortList(filelist,nSortType[0]);
  2056.     }
  2057. SetMenuValues();
  2058. }
  2059.  
  2060.  
  2061. int mgetgetbydir (void)
  2062. {
  2063. nSortType[1] = SORTBYDIR;
  2064.  
  2065. SortList(getlist,nSortType[1]);
  2066. }
  2067.  
  2068.  
  2069. int mgetgetbysize (void)
  2070. {
  2071. nSortType[1] = SORTBYSIZE;
  2072.  
  2073. SortList(getlist,nSortType[1]);
  2074. }
  2075.  
  2076.  
  2077. int mgetgetbyname (void)
  2078. {
  2079. nSortType[1] = SORTBYNAME;
  2080.  
  2081. SortList(getlist,nSortType[1]);
  2082. }
  2083.  
  2084.  
  2085. int mgetgetbydesc (void)
  2086. {
  2087. nSortType[1] = SORTBYDESC;
  2088.  
  2089. SortList(getlist,nSortType[1]);
  2090. }
  2091.  
  2092.  
  2093. int mgetgetbyage (void)
  2094. {
  2095. nSortType[1] = SORTBYAGE;
  2096.  
  2097. SortList(getlist,nSortType[1]);
  2098. }
  2099.  
  2100.  
  2101. int mgetgetkeep (void)
  2102. {
  2103.     if (nKeepSorted[1] == TRUE) 
  2104.     {
  2105.         nKeepSorted[1] = FALSE;
  2106.     }
  2107.     else
  2108.     {
  2109.         nKeepSorted[1] = TRUE;
  2110.         SortList(getlist,nSortType[1]);
  2111.     }
  2112.     SetMenuValues();
  2113. }
  2114.  
  2115.  
  2116.  
  2117.  
  2118.  
  2119. int SearchList(char *key, int nSearchType)
  2120. {
  2121.     int found = 0, nTemp = 0, nSearchDir = SEARCH_FORWARD;
  2122.     char sUpperBuffer[MAXFILELINELENGTH], sUpperSearchString[MAXFILELINELENGTH];
  2123.  
  2124.      pcWhatToAbort = "Search";
  2125.                        
  2126.     /* keep a separate temporary search_* in case we fail */
  2127.     int temp_search_index;
  2128.     struct Node *temp_search_current;
  2129.  
  2130.     if (mgetWnd != NULL) SetWindowTitles(mgetWnd, "Searching...", (char *) ~0); 
  2131.     SetWaitPointer(mgetWnd);
  2132.  
  2133.      /* make sure search_current at least is *something* !! */
  2134.      if (search_current == NULL)
  2135.      {
  2136.         search_current = ListViewTopNode((struct Gadget *) mgetGadgets[0], filelist);
  2137.         search_index = ListViewTop((struct Gadget *) mgetGadgets[0], filelist);
  2138.     }
  2139.  
  2140.     /* temporary copy */
  2141.     temp_search_current = search_current;
  2142.     temp_search_index = search_index;
  2143.     
  2144.     /* Start at current top of display */
  2145.     switch (nSearchType)
  2146.     {
  2147.         case SEARCHTYPE_FORWARD:
  2148.             temp_search_current = ListViewTopNode((struct Gadget *) mgetGadgets[0], filelist);
  2149.             temp_search_index = ListViewTop((struct Gadget *) mgetGadgets[0], filelist);
  2150.             break;
  2151.     
  2152.         case SEARCHTYPE_BACKWARD:
  2153.             temp_search_current = ListViewTopNode((struct Gadget *) mgetGadgets[0], filelist);
  2154.             temp_search_index = ListViewTop((struct Gadget *) mgetGadgets[0], filelist);
  2155.             nSearchDir = SEARCH_BACKWARD;
  2156.             break;
  2157.             
  2158.         case SEARCHTYPE_NEXT:
  2159.             temp_search_current = temp_search_current->ln_Succ;
  2160.             temp_search_index++;
  2161.             break;
  2162.         
  2163.         case SEARCHTYPE_PREVIOUS:
  2164.             if (temp_search_current != filelist->lh_Head) temp_search_current = temp_search_current->ln_Pred;
  2165.                 else temp_search_current = NULL;
  2166.             temp_search_index--;
  2167.             nSearchDir = SEARCH_BACKWARD;
  2168.                 break;
  2169.             
  2170.         case SEARCHTYPE_TOP:
  2171.             temp_search_current = filelist->lh_Head;
  2172.             temp_search_index = 0;
  2173.             break;
  2174.             
  2175.         case SEARCHTYPE_BOTTOM:
  2176.             temp_search_current = TailOf(filelist, &temp_search_index);
  2177.             nSearchDir = SEARCH_BACKWARD;
  2178.             break;        
  2179.     }        
  2180.             
  2181.  
  2182.     if (searchcasesensitive)    
  2183.     {
  2184.         while ((temp_search_current != NULL)&&(found == 0))
  2185.         {
  2186.             if ((temp_search_current->ln_Name != NULL)&&(strstr(temp_search_current->ln_Name,searchstring) != 0))
  2187.             found = 1;
  2188.             else
  2189.             {
  2190.                 if (nSearchDir == SEARCH_FORWARD)
  2191.                 {
  2192.                     temp_search_current = temp_search_current->ln_Succ; 
  2193.                     temp_search_index++;
  2194.                 }
  2195.                 else
  2196.                 {
  2197.                     temp_search_current = temp_search_current->ln_Pred; 
  2198.                     temp_search_index--;
  2199.                 }
  2200.             }
  2201.             if (CheckForUserAbort() == TRUE) temp_search_current = NULL;
  2202.         }
  2203.     }
  2204.     else
  2205.     {
  2206.         strncpy(sUpperSearchString,key,sizeof(sUpperSearchString));
  2207.         UpperCase(sUpperSearchString);
  2208.         while ((temp_search_current != NULL)&&(found == 0))
  2209.         {
  2210.             if (temp_search_current->ln_Name != NULL)
  2211.             {
  2212.                 strncpy(sUpperBuffer,temp_search_current->ln_Name,sizeof(sUpperBuffer)-1);
  2213.                 UpperCase(sUpperBuffer);
  2214.                 if (strstr(sUpperBuffer,sUpperSearchString) != 0) found = 1;
  2215.             }
  2216.             if (found == 0)
  2217.             {
  2218.                  if (nSearchDir == SEARCH_FORWARD)
  2219.                 {
  2220.                     temp_search_current = temp_search_current->ln_Succ; 
  2221.                     temp_search_index++;
  2222.                 }
  2223.                 else
  2224.                 {
  2225.                     if (temp_search_current == filelist->lh_Head) temp_search_current = NULL; 
  2226.                                          else temp_search_current = temp_search_current->ln_Pred; 
  2227.                     temp_search_index--;
  2228.                 }
  2229.             }
  2230.             if (CheckForUserAbort() == TRUE) temp_search_current = NULL;
  2231.         }
  2232.     }
  2233.     
  2234.     ChangeWindowTitle();
  2235.     ClearWaitPointer(mgetWnd);
  2236.  
  2237.     if (found == 1) 
  2238.     {    
  2239.         search_current = temp_search_current;        /* cast the temp copy in stone */
  2240.         search_index = temp_search_index;
  2241.         return(search_index); 
  2242.     }
  2243.     else 
  2244.     {
  2245.         return(-1);
  2246.     }
  2247. }
  2248.  
  2249.  
  2250.  
  2251.  
  2252.  
  2253.  
  2254.  
  2255.  
  2256.  
  2257.  
  2258.  
  2259. void findgadgoto (int index, int numberofflashes)
  2260. {
  2261. int i, xmin, ymin, xmax, ymax, ystep, midscreen;
  2262. int WindowHeightLines = nTopListHeight/(listfont.ta_YSize);
  2263. LONG yTop = 0;
  2264.  
  2265.  midscreen = index-(WindowHeightLines/2);
  2266.  if (midscreen < 0) midscreen = 0;
  2267.  
  2268.  GT_SetGadgetAttrs((struct Gadget *) mgetGadgets[0], mgetWnd, NULL, GTLV_Top, midscreen, TAG_END);
  2269.  yTop = ListViewTop((struct Gadget *) mgetGadgets[0], mgetWnd);
  2270.  ystep = index - yTop;
  2271.   
  2272.  xmin = Scr->WBorLeft + 4;
  2273.  ymin = (nTopListTop + ((listfont.ta_YSize) *ystep) + 2);
  2274.  xmax = windowwidth - Scr->WBorLeft - 20;
  2275.  ymax = ymin + (listfont.ta_YSize) - 1;
  2276.  
  2277.  SetDrMd(mgetWnd->RPort, 50); 
  2278.  for (i=0;i<numberofflashes;i++)
  2279.      {
  2280.      RectFill(mgetWnd->RPort,xmin,ymin,xmax,ymax);
  2281.      Delay(5);
  2282.      RectFill(mgetWnd->RPort,xmin,ymin,xmax,ymax);
  2283.      if (i<(numberofflashes-1)) Delay(5);
  2284.      }
  2285. }
  2286.  
  2287.  
  2288.  
  2289.  
  2290.  
  2291. int ClearList(struct List *thislist)
  2292. {
  2293.     struct Node *current;
  2294.     const int nodesize = sizeof(struct Node);
  2295.     BOOL BOnScreen = ((thislist == filelist)||(thislist == getlist));
  2296.     int nUpdate, nTally = 0;
  2297.         
  2298.     if (thislist == NULL) return(FALSE);
  2299.     if (thislist == filelist) 
  2300.     {
  2301.         search_current = NULL;
  2302.         filelist_length = 0;
  2303.     }
  2304.     if (thislist == getlist)
  2305.     {    
  2306.         getlist_length = 0;
  2307.         kbytes_selected = 0;
  2308.     }        
  2309.     if (BOnScreen == TRUE) AttachLists(FALSE);
  2310.  
  2311.     pcWhatToAbort = "Clear";
  2312.     
  2313.     SetWaitPointer(mgetWnd);
  2314.         
  2315.     while (current = RemHead(thislist))
  2316.     {
  2317.         if (current->ln_Name != NULL)
  2318.         {
  2319.             #ifdef MEMPOOLS_H
  2320.             free(current->ln_Name);
  2321.             #else
  2322.             FreeMem(current->ln_Name,current->ln_Pri+127);
  2323.                         #endif
  2324.         }        
  2325.         #ifdef MEMPOOLS_H
  2326.         free(current);
  2327.         #else                
  2328.         FreeMem(current,nodesize);   
  2329.         #endif
  2330.  
  2331.         if (nUpdate == 0) 
  2332.         {
  2333.             if (CheckForUserAbort() == TRUE) break;
  2334.             if (mgetWnd != NULL) 
  2335.             {
  2336.                 sprintf(windowtitle,"Clearing List: %i",nTally);
  2337.                 SetWindowTitles(mgetWnd, windowtitle, (char *) ~0);
  2338.             }
  2339.         }
  2340.         if (nUpdate < 0) nUpdate = 213;
  2341.         nUpdate--;
  2342.         nTally++;
  2343.         
  2344.     }
  2345.     if (BOnScreen == TRUE) AttachLists(TRUE);
  2346.     ClearWaitPointer(mgetWnd);
  2347.     return(TRUE);
  2348. }
  2349.  
  2350.  
  2351.  
  2352.  
  2353.  
  2354.  
  2355. int mgetclearfiles (void)
  2356. {
  2357.        /* delete files list */
  2358.        ClearList(filelist);    
  2359.        ChangeWindowTitle();
  2360. }
  2361.  
  2362.  
  2363.  
  2364. int mgetclearget (void)
  2365. {
  2366.     /* delete get list */
  2367.     ClearList(getlist);
  2368.        ChangeWindowTitle();
  2369. }
  2370.  
  2371.  
  2372.  
  2373.  
  2374.  
  2375.  
  2376.  
  2377. int mgetnoparse (void)
  2378. {
  2379.     if (noparse) 
  2380.     {
  2381.         noparse = 0; 
  2382.         if (nKeepSorted[0] == 1) SortList(filelist,nSortType[0]);
  2383.         if (nKeepSorted[1] == 1) SortList(getlist, nSortType[1]);
  2384.         SetMenuValues();
  2385.     }
  2386.     else 
  2387.     {
  2388.         noparse = 1;        
  2389.         SetMenuValues();
  2390.     }
  2391. }
  2392.  
  2393.  
  2394.  
  2395.  
  2396.  
  2397.  
  2398.  
  2399.  
  2400. int mgetfiles (void)
  2401. {
  2402.     if (filesflag) 
  2403.     {
  2404.         filesflag = 0;
  2405.         getreadmes = 1;
  2406.         SetMenuValues();     
  2407.     }
  2408.     else filesflag = 1;
  2409. }
  2410.  
  2411.  
  2412.  
  2413.  
  2414.  
  2415.  
  2416.  
  2417. int mgetreadmes (void)
  2418. {
  2419.     if (getreadmes) 
  2420.     {
  2421.         getreadmes = 0; 
  2422.          filesflag = 1;
  2423.          SetMenuValues();
  2424.     }
  2425.     else getreadmes = 1;
  2426. }
  2427.  
  2428.  
  2429.  
  2430.  
  2431.  
  2432.  
  2433. int mgetsplit (void)
  2434. {
  2435.     nosplit = Not[nosplit];
  2436.     SetMenuValues();    
  2437. }
  2438.  
  2439.  
  2440.  
  2441.  
  2442.  
  2443.  
  2444. int mgetlinelength (void)
  2445. {
  2446.     int lin;
  2447.  
  2448.     requesttype = LINELENGTH_REQUESTTYPE;    /* This is a HORRIBLE way to program, but I don't want  */
  2449.     lin = mgetfind();            /* to try to change the parameters since it might screw */
  2450.     requesttype = FIND_REQUESTTYPE;        /* up the mget_listview2 functions...                 */
  2451.  
  2452.     if (lin >  0) maxoutputlinelength = lin;
  2453. }
  2454.  
  2455.  
  2456.  
  2457.  
  2458. int mgetoutputfile (void)
  2459. {
  2460.     int lin;    
  2461.  
  2462.     requesttype = OUTPUTFILE_REQUESTTYPE;    /* This is a HORRIBLE way to program, but I don't want  */
  2463.     lin = mgetfind();            /* to try to change the parameters since it might screw */
  2464.     requesttype = FIND_REQUESTTYPE;        /* up the mget_listview2 functions...            */
  2465. }
  2466.  
  2467.  
  2468.  
  2469.  
  2470.  
  2471. #ifdef DEBUG
  2472. void PrintList(struct List *thislist)
  2473. {
  2474. struct Node *nodecurrent = thislist->lh_Head;
  2475.  
  2476. fprintf(fpOut,"thislist = %p\n",thislist);
  2477.  
  2478.  while (nodecurrent != NULL)
  2479.  {
  2480.     if (nodecurrent->ln_Name == NULL) 
  2481.         fprintf(fpOut,"[ <NULL> ]\n"); 
  2482.     else 
  2483.         fprintf(fpOut,"[%s]\n",nodecurrent->ln_Name);
  2484.  
  2485.     nodecurrent = nodecurrent->ln_Succ;
  2486.  }
  2487.     
  2488. return();
  2489. }
  2490. #endif
  2491.  
  2492.  
  2493.  
  2494.  
  2495. int LengthOfList(struct List *thislist)
  2496. {
  2497.     struct Node *nodecurrent = thislist->lh_Head->ln_Succ;
  2498.     int nLength = 0;
  2499.     
  2500.      while (nodecurrent != NULL)
  2501.      {
  2502.          nLength++;
  2503.         nodecurrent = nodecurrent->ln_Succ;
  2504.      }
  2505.     
  2506.     return(nLength);
  2507. }
  2508.  
  2509.  
  2510.  
  2511.  
  2512. int mgetsave (void)
  2513. {
  2514.     FILE * fpTemp = fpOut;
  2515.  
  2516.     /* Confirm with ASL for really big files! */
  2517.     if (((filelist_length + getlist_length) > 10000) &&
  2518.         (RequestAFile(inputfile,TRUE) == FALSE)) return(FALSE);        
  2519.         
  2520.     fpOut = fopen(inputfile,"w");    
  2521.     if (fpOut == NULL)
  2522.     {
  2523.         MakeReq("Couldn't open file.",NULL,NULL);
  2524.         return (0);
  2525.     }
  2526.  
  2527.     strcpy(windowtitle,"Saving current state to ");
  2528.     strncat(windowtitle,inputfile,sizeof(windowtitle));
  2529.     if (mgetWnd != NULL) SetWindowTitles(mgetWnd, windowtitle, (char *) ~0);            
  2530.  
  2531.     RawOutputList(filelist);
  2532.     
  2533.     if (LengthOfList(getlist) > 0)
  2534.     {
  2535.         fprintf(fpOut,"%s\n",szBookMark);
  2536.         RawOutputList(getlist);
  2537.     }
  2538.     fclose(fpOut);
  2539.     
  2540.     fpOut = fpTemp;
  2541.     
  2542.     ChangeWindowTitle();
  2543. }
  2544.  
  2545.  
  2546. int mgetfastquit (void)
  2547. {
  2548.     CleanUp();
  2549.     exit(0);
  2550. }
  2551.  
  2552.  
  2553. int mgetsaveas (void)
  2554. {
  2555.     /* FileRequest a file */
  2556.     *inputfile = CHAR_NUL;
  2557.     if (RequestAFile(inputfile,TRUE) == FALSE) return(FALSE);
  2558.     
  2559.     mgetsave();
  2560. }
  2561.  
  2562.  
  2563. int mgetmarkexit (void)
  2564. {
  2565.     mgetsave();
  2566.     CleanUp();
  2567.     exit(0);
  2568. }
  2569.  
  2570.  
  2571. /* szFileName string must be readable AND writable! */
  2572. BOOL GetValidFile(char * szFileName)
  2573. {
  2574.     while (FileExists(szFileName) == FALSE)
  2575.      {
  2576.          /* If user aborted, stop trying */
  2577.         if (RequestAFile(szFileName,FALSE) == FALSE) return(FALSE);
  2578.      }
  2579.      SetReqDefaults(szFileName);
  2580.      return(TRUE);
  2581. }
  2582.  
  2583.  
  2584.  
  2585. BOOL FileExists(char * szFileName)
  2586. {
  2587.     FILE * fpTest = fopen(szFileName, "r");
  2588.      if (fpTest != NULL) fclose(fpTest);
  2589.      return(fpTest != NULL);
  2590. }
  2591.  
  2592.  
  2593. int mgetopenfile (void)
  2594. {
  2595.     return(OpenMgetFile(NULL));
  2596. }
  2597.  
  2598. int OpenMgetFile(char * szOptFileName)
  2599. {         
  2600.     /* If arg specified, adopt that */
  2601.     if (szOptFileName == NULL) 
  2602.     {
  2603.          szOptFileName  = inputfile;
  2604.          *szOptFileName = CHAR_NUL;    /* force requester */
  2605.         if (GetValidFile(szOptFileName) == FALSE) return(FALSE); 
  2606.     }
  2607.     else
  2608.         if (FileExists(szOptFileName) == FALSE) return(FALSE);
  2609.  
  2610.     SetReqDefaults(szOptFileName);
  2611.         
  2612.     ClearList(filelist);         
  2613.  
  2614.     /* These are all dependant on a given filelist, so RESET! */
  2615.     filelist_length = 0;
  2616.     search_current = NULL;
  2617.     search_index = 0;
  2618.  
  2619.     pcWhatToAbort = "Load";
  2620.     ReadmyFile(szOptFileName);
  2621.     search_current = NULL;
  2622.     search_index = 0;
  2623.  
  2624.     ChangeWindowTitle();
  2625.     return(1);
  2626. }
  2627.  
  2628.  
  2629.  
  2630. void AttachLists(BOOL BAttach)
  2631. {
  2632.     if (mgetWnd == NULL) return;
  2633.     
  2634.     if (BAttach == TRUE)
  2635.     {
  2636.          GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, filelist, TAG_END);
  2637.          GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, getlist, TAG_END);        
  2638.     }
  2639.     else
  2640.     {
  2641.          GT_SetGadgetAttrs(mgetGadgets[0], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  2642.          GT_SetGadgetAttrs(mgetGadgets[1], mgetWnd, NULL, GTLV_Labels, ~0, TAG_END);
  2643.     }
  2644. }
  2645.  
  2646.  
  2647.  
  2648.  
  2649. int mgetappend(void)
  2650. {
  2651.     AppendMgetFile(NULL);    
  2652. }
  2653.  
  2654.  
  2655. int AppendMgetFile(char * szOptFileName)
  2656. {
  2657.     int returnme = 0;
  2658.     
  2659.     pcWhatToAbort = "Append";
  2660.  
  2661.     /* If arg specified, adopt that */
  2662.      if (szOptFileName == NULL)
  2663.      {
  2664.          szOptFileName = inputfile;
  2665.          *inputfile = NUL;    /* force requester */
  2666.         if (GetValidFile(szOptFileName) == FALSE) return(FALSE); 
  2667.      }
  2668.      else
  2669.         if (FileExists(szOptFileName) == FALSE) return(FALSE);
  2670.          
  2671.     SetWaitPointer(mgetWnd);
  2672.     SetReqDefaults(szOptFileName);
  2673.  
  2674.  
  2675.      pcWhatToAbort = "Append";
  2676.     returnme = ReadmyFile(szOptFileName);
  2677.     ChangeWindowTitle();
  2678.     return(returnme);
  2679. }
  2680.  
  2681.  
  2682.  
  2683.  
  2684.  
  2685.  
  2686. int mgetCloseWindow (void)
  2687. {
  2688.     done=TRUE;
  2689. }
  2690.  
  2691.  
  2692. int mgeticonify (void)
  2693. {
  2694.     struct MsgPort        *myport  = NULL;
  2695.     struct AppIcon        *appicon = NULL;
  2696.     struct AppMessage    *amsg  = NULL;
  2697.     BOOL BOpen = FALSE;
  2698.     char szPathName[MAXFILENAMELENGTH] = "";
  2699.     char * pcTemp;
  2700.     static char * pcFileName;
  2701.  
  2702.     if (appIconObj == NULL) 
  2703.     {        
  2704.         /* Add path, if there isn't a base in the filename */
  2705.         pcTemp = strchr(pcExecName,':');
  2706.         if (pcTemp == NULL) strcpy(szPathName,"PROGDIR:");        
  2707.                    else pcFileName = pcTemp+1;
  2708.         pcTemp = strchr(pcExecName,'/');
  2709.         if (pcTemp != NULL) pcFileName = pcTemp+1;
  2710.             
  2711.         if (pcFileName == NULL) pcFileName = pcExecName;
  2712.         
  2713.         strncat(szPathName, pcExecName, sizeof(szPathName));
  2714.         appIconObj = GetDiskObjectNew(szPathName);
  2715.         
  2716.         /* backup--use default icon */
  2717.         if (appIconObj == NULL) 
  2718.         {
  2719.             appIconObj = GetDefDiskObject(WBTOOL);
  2720.             if (appIconObj == NULL) return(FALSE);
  2721.         }
  2722.     }
  2723.  
  2724.     /* The type must be set to NULL for an AppIcon */
  2725.     appIconObj->do_Type = 0L;
  2726.     
  2727.     myport = CreateMsgPort();
  2728.     if (myport)
  2729.     {
  2730.         AttachLists(FALSE);
  2731.         appicon = AddAppIconA(0L, 0L, pcFileName, myport, NULL, appIconObj, NULL);
  2732.         if (appicon)
  2733.         {
  2734.             ClosemgetWindow();
  2735.             CloseDownScreen();    /* this handles the workbenchscreen and publicscreen cases too */
  2736.             WaitPort(myport);
  2737.             BOpen = HandleAppEvents(myport);    /* will open screen and window again here */
  2738.             RemoveAppIcon(appicon);
  2739.         }
  2740.         /* Remove any pending messages */
  2741.         while (amsg = (struct AppMessage *) GetMsg(myport)) ReplyMsg((struct Message *)amsg);
  2742.         DeleteMsgPort(myport);
  2743.         AttachLists(TRUE);
  2744.     }
  2745.     ChangeWindowTitle();
  2746.     SetMenuValues();
  2747.     return(1);
  2748. }
  2749.  
  2750.  
  2751.  
  2752.  
  2753.  
  2754.  
  2755.  
  2756. void SetMenuValues (void)
  2757. {
  2758.  struct Menu *currentMenu = mgetMenus;
  2759.  struct MenuItem *currentItem, *currentSub;
  2760.  
  2761.  if (mgetWnd != NULL) ClearMenuStrip(mgetWnd);
  2762.  
  2763.  currentItem = currentMenu->FirstItem;      /* Project Menu -- Open */
  2764.  currentItem = currentItem->NextItem;     /* Append */
  2765.  currentItem = currentItem->NextItem;     /* Save */
  2766.  currentItem = currentItem->NextItem;     /* Save As */
  2767.  currentItem = currentItem->NextItem;     /* Clear  */
  2768.  currentItem = currentItem->NextItem;     /* About */
  2769.  currentItem = currentItem->NextItem;     /* Iconify */
  2770.  if ((IconBase == NULL)||(IconBase->lib_Version < 37))   
  2771.      currentItem->Flags &= ~(ITEMENABLED);
  2772.    else currentItem->Flags |= ITEMENABLED;    
  2773.  
  2774.  
  2775.  /* Make sure the CaseSensitive item in the second menu is checked correctly. */    
  2776.  currentMenu = currentMenu->NextMenu;     /* Search Menu */
  2777.  currentItem = currentMenu->FirstItem;      /* #1 : Find Forward */
  2778.  currentItem = currentItem->NextItem;      /* #2 : Find Backward*/
  2779.  currentItem = currentItem->NextItem;      /* #3 : Find from Top */
  2780.  currentItem = currentItem->NextItem;      /* #4 : Find from Bottom */
  2781.  currentItem = currentItem->NextItem;      /* #5 : Find Next */
  2782.  currentItem = currentItem->NextItem;      /* #5 : Find Previous */
  2783.  currentItem = currentItem->NextItem;     /* #6 : Find Current */
  2784.  currentItem = currentItem->NextItem;     /* #6 : Select */
  2785.  currentItem = currentItem->NextItem;     /* #6 : Deselect */
  2786.  currentItem = currentItem->NextItem;      /* #6 : Case Sensitive. */
  2787.  
  2788.  if (searchcasesensitive)  currentItem->Flags |= CHECKED; 
  2789.             else  currentItem->Flags &= ~(CHECKED);    
  2790.  
  2791.  /* next we do the Sort menu. */
  2792.  currentMenu = currentMenu->NextMenu;
  2793.  if (noparse) currentMenu->Flags &= ~(MENUENABLED);
  2794.        else currentMenu->Flags |= MENUENABLED;
  2795.  
  2796.  currentItem = currentMenu->FirstItem;    /* #1: Files List */
  2797.  currentSub = currentItem->SubItem;    /* #1.1 : By Directory */
  2798.  
  2799.  currentSub = currentSub->NextItem;    /* #1.2 : By Size */
  2800.  
  2801.  currentSub = currentSub->NextItem;    /* #1.3 : By FileName */
  2802.  currentSub = currentSub->NextItem;    /* #1.4 : By Description */
  2803.  currentSub = currentSub->NextItem;    /* #1.5 : By Age */
  2804.  currentSub = currentSub->NextItem;    /* #1.6 : Keep Sorted */
  2805.  if (nKeepSorted[0] == 0) currentSub->Flags &= ~(CHECKED);
  2806.                            else currentSub->Flags |= CHECKED;
  2807.  
  2808.  currentItem = currentItem->NextItem;  /* #2: Get List */
  2809.  currentSub = currentItem->SubItem;    /* #2.1 : By Directory */
  2810.  currentSub = currentSub->NextItem;    /* #2.2 : By Size */
  2811.  currentSub = currentSub->NextItem;    /* #2.3 : By FileName */
  2812.  currentSub = currentSub->NextItem;    /* #2.4 : By Description */
  2813.  currentSub = currentSub->NextItem;    /* #2.5 : By Age */
  2814.  currentSub = currentSub->NextItem;    /* #2.6 : Keep Sorted */
  2815.  if (nKeepSorted[1] == 0) currentSub->Flags &= ~(CHECKED);
  2816.                            else currentSub->Flags |= CHECKED;
  2817.  
  2818.                                       
  2819.  currentItem = currentItem->NextItem;    /* #3: Sort Type */
  2820.  currentSub = currentItem->SubItem;    /* #3.1: Tree Sort */
  2821.  if (nSortAlgorithm == TREESORT) currentSub->Flags |= CHECKED;
  2822.                    else currentSub->Flags &= ~(CHECKED);
  2823.  currentSub = currentSub->NextItem;        /* #3.2: Bubble Sort */
  2824.  if (nSortAlgorithm == BUBBLESORT)   currentSub->Flags |= CHECKED;
  2825.                  else currentSub->Flags &= ~(CHECKED);
  2826.  
  2827.  currentItem = currentItem->NextItem;    /* #4: Case Sensitive */
  2828.  if (sortcasesensitive == FALSE) currentItem->Flags &= ~(CHECKED);
  2829.                                       else currentItem->Flags |= (CHECKED);
  2830.                                         
  2831.                           
  2832.  /* Output menu. */
  2833.  currentMenu = currentMenu->NextMenu;
  2834.  
  2835.  currentItem = currentMenu->FirstItem;        /* #1: Aminet Parse */
  2836.  
  2837.  if (noparse) currentItem->Flags &= ~(CHECKED);
  2838.        else currentItem->Flags |= CHECKED;
  2839.        
  2840.        
  2841.  currentItem = currentItem->NextItem;        /* #2: Get Files */
  2842.  
  2843.  if (noparse) currentItem->Flags &= ~(ITEMENABLED);
  2844.        else currentItem->Flags |= ITEMENABLED;
  2845.  if (filesflag) currentItem->Flags |= CHECKED;
  2846.           else currentItem->Flags &= ~(CHECKED);
  2847.           
  2848.  currentItem = currentItem->NextItem;        /* #3: Get Readmes */
  2849.  if (noparse) currentItem->Flags &= ~(ITEMENABLED);
  2850.        else currentItem->Flags |= ITEMENABLED;
  2851.  if (getreadmes) currentItem->Flags |= CHECKED;
  2852.            else currentItem->Flags &= ~(CHECKED);
  2853.     
  2854.  currentItem = currentItem->NextItem;        /* #4: Split Commands */
  2855.  
  2856.  if (noparse) currentItem->Flags &= ~(ITEMENABLED);
  2857.        else currentItem->Flags |= ITEMENABLED;
  2858.  if (nosplit) currentItem->Flags &= ~(CHECKED);
  2859.            else currentItem->Flags |= CHECKED;
  2860.            
  2861.  
  2862.  currentItem = currentItem->NextItem;        /* #5: Use CD's */
  2863.  if (noparse) currentItem->Flags &= ~(ITEMENABLED);
  2864.        else currentItem->Flags |= ITEMENABLED;
  2865.  if (simplepaths) currentItem->Flags |= CHECKED;
  2866.            else currentItem->Flags &= ~(CHECKED);
  2867.            
  2868.  currentItem = currentItem->NextItem;        /* #6: Line length */
  2869.  if ((noparse)||(nosplit)) currentItem->Flags &= ~(ITEMENABLED);
  2870.        else currentItem->Flags |= ITEMENABLED;
  2871.  
  2872.  ResetMenuStrip( mgetWnd, mgetMenus );                 
  2873. }
  2874.  
  2875.  
  2876.  
  2877.  
  2878.  
  2879.  
  2880. /* Turns all \n's in input string into <space><newline>'s */
  2881. void FindReturns(char *mystring)
  2882. {
  2883.  char *thischar=mystring, *prevchar=mystring;
  2884.  
  2885.  while (*thischar != NULL)
  2886.  {
  2887.     
  2888.     if ( (*prevchar  ==   92) &&                        /* any '/'s ? */
  2889.          ((*thischar ==   78)||(*thischar == 110)) &&      /* N's or n's */
  2890.          (prevchar   !=  NULL) &&                        /* Sanity chk */
  2891.          (thischar   !=  NULL))
  2892.         
  2893.         {
  2894.         *prevchar = CHAR_SPACE;   /* set this to a space--easier than shortening string */
  2895.         *thischar = CHAR_NEWLINE;   /* and end this line with a newline char */
  2896.         }
  2897.     prevchar = thischar;
  2898.     thischar++;
  2899.  }
  2900. }
  2901.  
  2902.  
  2903.  
  2904.  
  2905.  
  2906.  
  2907.  
  2908.  
  2909.  
  2910. int AddFile(struct List *mylist, char *newstring, int stringlength)
  2911. {
  2912.  struct Node *newnode;
  2913.  char *newname;
  2914.  UBYTE diff = MAXFILELINELENGTH;
  2915.  const int minlinelength = 1;
  2916.  
  2917.  if (keepblanklines == 1) minlinelength = 0;
  2918.  if ((newstring == NULL)||((omitcomments == TRUE)&&(*newstring==cCommentChar))) return(0);
  2919.  
  2920. #ifdef MEMPOOLS_H
  2921.  if (!(newnode = (struct Node *) malloc(sizeof(struct Node))))
  2922. #else
  2923.  if (!( newnode = AllocMem(sizeof(struct Node),MEMF_CLEAR) ))
  2924. #endif
  2925.  {
  2926.     /* emergency bailout! */
  2927.     ClearList(filelist); 
  2928.     filelist = NULL;
  2929.     
  2930.     #ifdef MEMPOOLS_H
  2931.         free(filelist);
  2932.     #else
  2933.     FreeMem(filelist,sizeof(struct List));
  2934.     #endif
  2935.     
  2936.     MakeReq("AddFile:  Aborting due to lack of memory",NULL,NULL);
  2937.     CleanUp();
  2938.     exit(20);
  2939.  }
  2940.  
  2941. #ifdef MEMPOOLS_H
  2942.  if (!( newname = (char *) malloc(stringlength+1)))
  2943. #else
  2944.  if (!( newname = AllocMem(stringlength+1,MEMF_CLEAR) ))
  2945. #endif
  2946.  {
  2947.     /* emergency bailout! */
  2948.     #ifdef MEMPOOLS_H
  2949.     free(newnode);
  2950.     #else
  2951.     FreeMem(newnode,sizeof(struct Node));
  2952.     #endif
  2953.     
  2954.     ClearList(filelist); 
  2955.     filelist = NULL;
  2956.     
  2957.     #ifdef MEMPOOLS_H
  2958.     free(filelist);
  2959.     #else
  2960.     FreeMem(filelist,sizeof(struct List));
  2961.     #endif
  2962.     
  2963.     MakeReq("AddFile:  Aborting due to lack of memory",NULL,NULL);
  2964.     CleanUp();
  2965.     exit(20);
  2966.  }
  2967.  memset(newname,CHAR_NUL,stringlength+1);    /* clear bytes--this can probably be removed later */
  2968.      
  2969. strncpy(newname,newstring,stringlength);   /* copy over the bytes */
  2970.  
  2971. newnode->ln_Pri = stringlength - 126;    /* store string length in unused field */
  2972. newnode->ln_Name=newname;          /* and set ze pointer! */
  2973.  
  2974. AddTail(mylist, newnode);
  2975. return(1);
  2976. }
  2977.  
  2978.  
  2979.  
  2980. /* Prints out a file.  Makes sure there is a sEndOfLineString after the end of every line */
  2981. int PrintFile(char *szFileName, int PrintReturnFirst)
  2982. {
  2983.     FILE *input_file = fopen(szFileName,"r");
  2984.     char inputline[MAXFILELINELENGTH], *a, *b;
  2985.     int nLen;
  2986.  
  2987.      if (input_file == NULL) 
  2988.      {
  2989.         return(0);
  2990.      }
  2991.  
  2992.      if (PrintReturnFirst == 1)
  2993.      {
  2994.          fprintf(fpOut,sEndOfLineString);
  2995.          
  2996.      }
  2997.          
  2998.     /* Read until we get a line-end */
  2999.     while(!feof(input_file))
  3000.     {
  3001.         memset(inputline,NUL,MAXFILELINELENGTH);
  3002.         fgets(inputline,MAXFILELINELENGTH,input_file);  /* Read up to MAXFILELINELENGTH chars from inputfile */
  3003.         
  3004.         nLen = strlen(inputline);
  3005.         
  3006.         if (nLen >= 2)
  3007.         {
  3008.             /* make sure that it ends in a sEndOfLineString */
  3009.             a = &inputline[strlen(inputline)-2];
  3010.             b = &inputline[strlen(inputline)-1];
  3011.             
  3012.             if ((*a == '\r')&&(*b == '\n')) /* the easy case */
  3013.             {
  3014.                 fprintf(fpOut,"%s",inputline);
  3015.             }
  3016.             else
  3017.             {
  3018.                 if ((*a != '\r')&&(*b == '\n'))  /* the normal case, for Amigas */
  3019.                 {
  3020.                 /* make the newline a return, and then append a newline */
  3021.                     *b = '\r';
  3022.                     fprintf(fpOut,"%s\n",inputline);
  3023.                 }
  3024.                 else
  3025.                 {
  3026.                 if ((*a == '\r')&&(*b != '\n'))    /* the abnormal case */
  3027.                     {
  3028.                         *b = '\n';
  3029.                         fprintf(fpOut,"%s",inputline);
  3030.                     }
  3031.                     else
  3032.                     {
  3033.                         /* *a != \r, *b != \n */
  3034.                         fprintf(fpOut,"%s%s",inputline,sEndOfLineString);
  3035.                     }
  3036.                 }
  3037.             }
  3038.         }
  3039.         else
  3040.         if (nLen == 1) fprintf(fpOut,sEndOfLineString);
  3041.     }    
  3042.     fclose(input_file);
  3043.     return(1);
  3044. }
  3045.  
  3046.  
  3047. BOOL FillLoadBuffer(FILE * fpIn, UBYTE bWhich)
  3048. {
  3049.     int nBufferSize = nLoadBufferSize/3;
  3050.     int nBytesRead;
  3051.     
  3052.     if (fpIn == NULL) return(FALSE);
  3053.     if (pcEOFat != NULL) return(FALSE);
  3054.     
  3055.     if (bWhich & 0x01)
  3056.     {
  3057.         nBytesRead = fread(szLoadBuffer1, sizeof(UBYTE), nBufferSize, fpIn);
  3058.         /* printf("Filling Buffer 1, (read %i of %i)\n",nBytesRead, nBufferSize);  */
  3059.  
  3060.         if (nBytesRead < nBufferSize)
  3061.         {
  3062.             /* found EOF! */
  3063.             pcEOFat = &szLoadBuffer1[nBytesRead];
  3064.             *pcEOFat = CHAR_NUL;    /* NULL terminate here */
  3065.             return(TRUE);
  3066.         }
  3067.     }
  3068.     
  3069.     if (bWhich & 0x02)
  3070.     {
  3071.         nBytesRead = fread(szLoadBuffer2, sizeof(UBYTE), nBufferSize, fpIn);
  3072.         /* printf("Filling Buffer 2, (read %i of %i)\n",nBytesRead, nBufferSize); */
  3073.         if (nBytesRead < nBufferSize)
  3074.         {
  3075.             /* found EOF! */
  3076.             pcEOFat = &szLoadBuffer2[nBytesRead];
  3077.             *pcEOFat= CHAR_NUL;    /* NULL terminate here */
  3078.             return(TRUE);
  3079.         }
  3080.     }
  3081.  
  3082.     if (bWhich & 0x04)
  3083.     {
  3084.         nBytesRead = fread(szLoadBuffer3, sizeof(UBYTE), nBufferSize, fpIn);
  3085.         /* printf("Filling Buffer 3, (read %i of %i)\n",nBytesRead, nBufferSize); */
  3086.         if (nBytesRead < nBufferSize)
  3087.         {
  3088.             /* found EOF! */
  3089.             pcEOFat = &szLoadBuffer3[nBytesRead];
  3090.             *pcEOFat= CHAR_NUL;    /* NULL terminate here */
  3091.             return(TRUE);
  3092.         }
  3093.     }
  3094.  
  3095.     return(TRUE);
  3096. }
  3097.  
  3098.  
  3099. /* operates much like strchr, only knows to wrap around once. */
  3100. char * FindCharInBuffer(char * szStartAt, char cLookForArg)
  3101. {    
  3102.     register char * pcTemp = szStartAt;
  3103.     register char * szBeganAt = szStartAt;
  3104.     register char cLookFor = cLookForArg;
  3105.     
  3106.     while ((*pcTemp != CHAR_NUL)&&(*pcTemp != cLookFor))
  3107.     {        
  3108.         pcTemp++;
  3109.         if (pcTemp >= szLoadBufferT) pcTemp = szLoadBuffer1;
  3110.         else if (pcTemp == szBeganAt) return(NULL);
  3111.     }
  3112.     return(pcTemp);
  3113. }
  3114.  
  3115.  
  3116.  
  3117. /* Return a pointer to the next sentence in the buffer */
  3118. char * GetMoreText(FILE * fpIn)
  3119. {
  3120.     int nStartPartition=0, nEndPartition=0;
  3121.     char *pcStartOfString; 
  3122.     char *pcEndOfString;
  3123.     static BOOL BThisIsTheLast = FALSE;
  3124.     
  3125.     if (BThisIsTheLast == TRUE)
  3126.     {
  3127.         BThisIsTheLast = FALSE;
  3128.         return(NULL);
  3129.     }
  3130.     
  3131.     
  3132.     /* Make sure we don't go off the end */
  3133.     if (pcLoadCurrent >= szLoadBufferT) pcStartOfString = szLoadBuffer1;
  3134.     
  3135.     /* Get start (first char) and end (nul char) of current string */
  3136.     pcStartOfString = pcLoadCurrent;
  3137.  
  3138.  
  3139.     /* Find the end of the current line */
  3140.     pcEndOfString = FindCharInBuffer(pcStartOfString, CHAR_NEWLINE);
  3141.     if (pcEndOfString == NULL) return(NULL);    /* should never happen! */
  3142.         
  3143.     
  3144.     /* terminate our string */
  3145.     *pcEndOfString = CHAR_NUL;
  3146.     if (*(pcEndOfString-1) == CHAR_RETURN) *(pcEndOfString-1) = CHAR_SPACE;
  3147.  
  3148.     /* If we're at the EOF, then cause the file loading to stop */
  3149.     if (pcStartOfString == pcEOFat) return(NULL);
  3150.     
  3151.     /* If we somehow skip over the EOF, we'll return this line and then 
  3152.        be sure to return NULL next time */
  3153.     if (pcEOFat)
  3154.     {
  3155.         if (((pcStartOfString <= pcEOFat)&&(pcEndOfString >= pcEOFat)) ||
  3156.             ((pcStartOfString >= pcEOFat)&&(pcEndOfString <= pcEOFat)))
  3157.                  BThisIsTheLast = TRUE;
  3158.     }
  3159.     
  3160.     /* Cases:
  3161.     
  3162.         1) Entirely in buffer 1.   Return pointer to string.
  3163.         2) Entirely in buffer 2.    ""
  3164.         3) Entirely in buffer 3.    ""
  3165.         4) In 1 and 2.            "", load buffer 3.  
  3166.         5) In 2 and 3.              "", load buffer 1.
  3167.         6) In 3 and 1.             Copy two pieces to szLoadBufferT, load buffer 2.
  3168.     */
  3169.  
  3170.     
  3171.     /* First figure out which case we're in. */
  3172.     if (pcStartOfString >= szLoadBuffer3) nStartPartition = 3;    
  3173.     else if (pcStartOfString >= szLoadBuffer2) nStartPartition = 2;
  3174.       else if (pcStartOfString >= szLoadBuffer1) nStartPartition = 1;
  3175.  
  3176.     if (pcEndOfString == (szLoadBufferT-1)) nEndPartition = 1;    /* wrap around */
  3177.     else if (pcEndOfString >= szLoadBuffer3) nEndPartition = 3;
  3178.     else if (pcEndOfString >= szLoadBuffer2) nEndPartition = 2;
  3179.     else if (pcEndOfString >= szLoadBuffer1) nEndPartition = 1;
  3180.     
  3181.     /* If start and end aren't in one partition, do extra stuff */
  3182.     if (nStartPartition != nEndPartition)
  3183.     {
  3184.         if ((nStartPartition == 1)&&(nEndPartition == 2)) 
  3185.         {
  3186.             FillLoadBuffer(fpIn, 0x4); 
  3187.         }
  3188.         else if ((nStartPartition == 2)&&(nEndPartition == 3)) 
  3189.         {
  3190.             FillLoadBuffer(fpIn, 0x1);
  3191.         }
  3192.         else if ((nStartPartition == 3)&&(nEndPartition == 1))
  3193.         {
  3194.             FillLoadBuffer(fpIn, 0x2); 
  3195.             *(szLoadBufferT-1) = CHAR_NUL;
  3196.             strncpy(szLoadBufferT,pcStartOfString,MAXFILELINELENGTH);
  3197.             strncat(szLoadBufferT,szLoadBuffer1,MAXFILELINELENGTH);
  3198.             pcStartOfString = szLoadBufferT;
  3199.             *(szLoadBufferT-1) = '~';
  3200.         }
  3201.     }
  3202.  
  3203.     /* Set this to the next string for next time */
  3204.     pcLoadCurrent = pcEndOfString+1;
  3205.     
  3206.     /* return the current string */
  3207.     return(pcStartOfString);
  3208. }
  3209.  
  3210.  
  3211.  
  3212.  
  3213. BOOL SetUpBufferPairs(FILE * fpIn, BOOL BAlloc)
  3214. {    
  3215.     if (BAlloc == TRUE)
  3216.     {
  3217.         /* Allocate memory */
  3218.         while (szLoadBuffer1 == NULL)
  3219.         {
  3220.             szLoadBuffer1 = (char *) malloc(nLoadBufferSize+1+MAXFILELINELENGTH);
  3221.             if (szLoadBuffer1 == NULL) 
  3222.             {    
  3223.                 nLoadBufferSize /= 10;
  3224.                 while ((nLoadBufferSize % 3) != 0) nLoadBufferSize++;
  3225.                 if (nLoadBufferSize < 1024) return(FALSE);
  3226.             }
  3227.         }
  3228.         
  3229.         if (szLoadBuffer1 == NULL) return(FALSE);
  3230.  
  3231.         szLoadBuffer2 = &szLoadBuffer1[nLoadBufferSize/3];
  3232.         szLoadBuffer3 = &szLoadBuffer1[2*nLoadBufferSize/3];
  3233.         
  3234.         szLoadBufferT = &szLoadBuffer1[nLoadBufferSize];
  3235.         *szLoadBufferT = '~';        
  3236.         szLoadBufferT++;        /* start overflow array after NUL */
  3237.         
  3238.         pcLoadCurrent = szLoadBuffer1;
  3239.         pcEOFat = NULL;
  3240.  
  3241.         FillLoadBuffer(fpIn, 0x1|0x2 );
  3242.     }
  3243.     else
  3244.     {
  3245.         /* Free memory, if it's allocated. */
  3246.         if (szLoadBuffer1 != NULL) 
  3247.         {
  3248.             free(szLoadBuffer1);
  3249.             szLoadBuffer1 = NULL;
  3250.             szLoadBuffer2 = NULL;
  3251.             szLoadBuffer3 = NULL;
  3252.             szLoadBufferT = NULL;
  3253.             pcEOFat       = NULL;
  3254.             pcLoadCurrent = NULL;
  3255.         }
  3256.     }
  3257.     return(TRUE);
  3258. }
  3259.  
  3260.  
  3261.  
  3262. /* returns the number of lines successfully parsed and added to the list */
  3263. int ReadmyFile(char * szInFile)
  3264. {
  3265.  FILE *input_file = NULL;
  3266.  char *inputline = NULL;
  3267.  int nStringLength, okline = 0, nUpdate = 50;
  3268.  int filelength = 0, failed_lines = 0;
  3269.  int minlinelength = 1;
  3270.  struct List * thislist = filelist;
  3271.  int nBookMarkLength = strlen(szBookMark);
  3272.  
  3273.  if (keepblanklines == 1) minlinelength = 0;
  3274.  
  3275.  input_file = fopen(szInFile,"r");
  3276.  if (input_file == NULL) return(FALSE);
  3277.  
  3278.  /* Valid file--set this now. */
  3279.  if (szInFile != inputfile) strncpy(inputfile, szInFile, sizeof(inputfile));
  3280.  
  3281.  SetWaitPointer(mgetWnd);
  3282.  
  3283.  SetReqDefaults(szInFile);
  3284.  
  3285.  AttachLists(FALSE);
  3286.  
  3287.  if (SetUpBufferPairs(input_file, TRUE) == FALSE)
  3288.       MakeReq("No memory for load buffers",NULL,NULL);
  3289.    else inputline = "";
  3290.  
  3291.  
  3292.  while (inputline)
  3293.  {
  3294.     filelength++;        
  3295.     okline=0;  
  3296.     /* Read until we get a line-end */
  3297.     while((!okline)&&(inputline))
  3298.     {
  3299.         /* Not necessary, I think: memset(inputline,NUL,MAXFILELINELENGTH); */
  3300.         inputline = GetMoreText(input_file);  /* Read up chars from szInFile buffer */
  3301.         if (inputline != NULL)
  3302.         {
  3303.             nStringLength = strlen(inputline);
  3304.             if ((nStringLength >= minlinelength)&&(nStringLength < MAXFILELINELENGTH)) okline=1;
  3305.         }
  3306.     }
  3307.     
  3308.     if ((inputline)&&((nStringLength < MAXFILELINELENGTH)||(noparse)))
  3309.     {        
  3310.         /* Check to see if we have a szBookMark */
  3311.         if (strncmp(inputline, szBookMark, nBookMarkLength) == 0) thislist = getlist;
  3312.         else
  3313.         {    
  3314.                   if (AddFile(thislist, inputline, nStringLength) == TRUE)
  3315.                   {
  3316.                       if (thislist == filelist) filelist_length++;
  3317.                           else if (thislist == getlist) 
  3318.                           {
  3319.                               if (!noparse) UpdateByteCount(inputline,1);
  3320.                               getlist_length++;
  3321.                           }
  3322.                 if (nUpdate == 0)
  3323.                 {
  3324.                     sprintf(windowtitle,"Loading: %i",filelist_length);
  3325.                     if (mgetWnd != NULL) SetWindowTitles(mgetWnd, windowtitle , (char *) ~0);
  3326.                     nUpdate = 125;
  3327.                     if (CheckForUserAbort() == TRUE) inputline = NULL;
  3328.                 }
  3329.                 else nUpdate--;
  3330.                  }
  3331.                   else failed_lines++;
  3332.         }
  3333.     }
  3334.     else failed_lines++;          
  3335.  }
  3336.  
  3337.  SetUpBufferPairs(input_file, FALSE);
  3338.  fclose(input_file);
  3339.  
  3340.  if ((nKeepSorted[0] == 1)&&(!noparse)) SortList(filelist,nSortType[0]);  /* keep sorted if that is selected! */
  3341.  if ((nKeepSorted[1] == 1)&&(!noparse)) SortList(getlist,nSortType[1]);  /* keep sorted if that is selected! */
  3342.  
  3343.  AttachLists(TRUE);
  3344.  
  3345.  ChangeWindowTitle();
  3346.  ClearWaitPointer(mgetWnd);    
  3347.  return(filelist_length);
  3348. }
  3349.  
  3350.  
  3351.  
  3352.  
  3353.  
  3354.  
  3355. void ChangeWindowTitle(void)
  3356. {
  3357.     char *fstring = inputfile, *f2;
  3358.     char sSubString[60];
  3359.     int charlength = (windowwidth-81)/8 - 40;
  3360.  
  3361.     if (mgetWnd == NULL) return;
  3362.     
  3363.     if (charlength <= 0) 
  3364.     {
  3365.         fstring = sSubString;
  3366.         fstring[0] = NUL;
  3367.     }
  3368.     else
  3369.     if (strlen(fstring) > charlength)
  3370.     {
  3371.         f2 = inputfile + strlen(inputfile) - charlength - 1;    
  3372.         if (f2 > inputfile)
  3373.         {
  3374.             fstring = sSubString;
  3375.             strcpy(fstring,f2);
  3376.         }
  3377.     }    
  3378.     sprintf(windowtitle,"(%s) %i files, %u kilobytes selected.",fstring, getlist_length, kbytes_selected);   
  3379.     SetWindowTitles(mgetWnd, windowtitle , (char *) ~0); 
  3380.     return();
  3381. }
  3382.  
  3383.  
  3384.  
  3385.  
  3386.  
  3387.  
  3388.  
  3389.  
  3390.  
  3391. VOID UpdateByteCount(char *mystring, int addorsub)
  3392. {
  3393.     kbytes_selected = kbytes_selected + (AminetFileSize(mystring) * addorsub);
  3394.     return();
  3395. }
  3396.  
  3397.  
  3398.  
  3399.  
  3400.  
  3401.  
  3402.  
  3403.  
  3404.  
  3405.  
  3406.  
  3407. VOID CleanUp(void)
  3408. {
  3409.  
  3410.  if ((fpOut != stdout)&&(fpOut != NULL)) fclose(fpOut);
  3411.  
  3412.  SetUpBufferPairs(NULL, FALSE);
  3413.  
  3414.  if (appIconObj) FreeDiskObject(appIconObj);
  3415.  
  3416.  if (listfontdata)  CloseFont(listfontdata);
  3417.  if (windowisopen)  {ClosemgetWindow();  windowisopen = FALSE; mgetWnd = NULL;}
  3418.  if (screenisopen)  {CloseDownScreen();  screenisopen = FALSE; Scr = NULL;}
  3419.  if (filelist)        
  3420.  {
  3421.      ClearList(filelist); 
  3422.      #ifdef MEMPOOLS_H
  3423.      free(filelist);
  3424.      #else
  3425.      FreeMem(filelist,sizeof(struct List));
  3426.      #endif
  3427.      
  3428.  }
  3429.  if (getlist) 
  3430.  {
  3431.      ClearList(getlist);
  3432.      
  3433.      #ifdef MEMPOOLS_H
  3434.      free(getlist);
  3435.      #else
  3436.      FreeMem(getlist,sizeof(struct List));
  3437.      #endif
  3438.  }
  3439.  if (WorkbenchBase) CloseLibrary((struct Library *)WorkbenchBase);
  3440.  if (IconBase)      CloseLibrary((struct Library *)IconBase);
  3441.  if (IntuitionBase) CloseLibrary((struct Library *)IntuitionBase);
  3442.  if (AslBase)        CloseLibrary((struct Library *)AslBase);
  3443.  if (UtilityBase)   CloseLibrary((struct Library *)UtilityBase);
  3444.  if (GraphicsBase)  CloseLibrary((struct GraphicsLib *)GraphicsBase);
  3445.  if (GadToolsBase)  CloseLibrary((struct Library *)GadToolsBase);
  3446.  return();
  3447. }
  3448.  
  3449.  
  3450.  
  3451.  
  3452.  
  3453.  
  3454.  
  3455.  
  3456.  
  3457.  
  3458.  
  3459. int RequestAFile(char *szBuffer, BOOL BSave)
  3460. {
  3461.     int rvalue = 1;
  3462.     LONG lFlags = FILF_PATGAD;
  3463.     char szOpen[] = "Open", szSave[] = "Save";
  3464.     char * szOkayText = szOpen;
  3465.     char * szHailText = "Select a text file to browse.";
  3466.     
  3467.     if (strlen(defDir) == 0) strcpy(defDir,"ram:");
  3468.     if (strlen(defFile)== 0) strcpy(defFile,"RECENT");
  3469.  
  3470.     SetWaitPointer(mgetWnd);
  3471.  
  3472.     if (BSave == TRUE) 
  3473.     {
  3474.         szHailText = "Select a file to save to.";
  3475.         lFlags |= FILF_SAVE;
  3476.         szOkayText = szSave;
  3477.     }
  3478.     
  3479.     struct TagItem frtags[] =
  3480.     {
  3481.         ASL_Hail,    (ULONG)szHailText,
  3482.         ASL_Height,    350,
  3483.         ASL_Width,    320,
  3484.         ASL_LeftEdge,    50,
  3485.         ASL_TopEdge,    35,
  3486.         ASL_OKText,    (ULONG)szOkayText,
  3487.         ASL_CancelText, (ULONG)"Cancel",
  3488.         ASL_File,    defFile,
  3489.         ASL_Dir,    defDir,
  3490.         ASL_Window,    mgetWnd,
  3491.         ASL_FuncFlags,  lFlags,
  3492.         ASL_Pattern,    szFilePattern,
  3493.         TAG_DONE
  3494.     };
  3495.  
  3496.     struct FileRequester *fr;
  3497.     
  3498.     fr = (struct FileRequester *) AllocAslRequest(ASL_FileRequest, frtags);
  3499.     if (fr == NULL) rvalue = 0;
  3500.             
  3501.      if ((rvalue)&&(AslRequest(fr, NULL)))
  3502.     {
  3503.         strcpy(szBuffer,fr->rf_Dir);
  3504.         strncpy(defDir,fr->rf_Dir,sizeof(defDir));
  3505.         strncpy(defFile,fr->rf_File,sizeof(defFile));
  3506.         if ((defDir[strlen(defDir)-1] != '/')&&
  3507.             (defDir[strlen(defDir)-1] != ':')) strcat(szBuffer,"/");
  3508.         strcat(szBuffer,fr->rf_File);
  3509.     }
  3510.     else rvalue = 0;
  3511.     
  3512.     if (fr != NULL) FreeAslRequest(fr);
  3513.     ClearWaitPointer(mgetWnd);
  3514.     if (rvalue == 1) SetReqDefaults(szBuffer);
  3515.     return(rvalue);
  3516. }
  3517.  
  3518.  
  3519.  
  3520.  
  3521. void SetWaitPointer(struct Window * mywin)
  3522. {
  3523.     if (mywin != NULL) SetPointer(mywin, waitPointer, 16, 16, -6, 0);
  3524. }
  3525.  
  3526. void ClearWaitPointer(struct Window * mywin)
  3527. {
  3528.     if (mywin != NULL) ClearPointer(mywin);
  3529. }
  3530.  
  3531.  
  3532.  
  3533.  
  3534.  
  3535. void TurnOnAllMenuItems(struct Menu *myMenu)
  3536. {
  3537. struct MenuItem *mItem;
  3538.  
  3539.  while (myMenu != NULL)
  3540.     {
  3541.     mItem = myMenu->FirstItem;
  3542.     while (mItem != NULL)
  3543.         {
  3544.         mItem->Flags |= ITEMENABLED;
  3545.         mItem = mItem->NextItem;
  3546.         }
  3547.     myMenu = myMenu->NextMenu;
  3548.     }
  3549. return;
  3550. }
  3551.  
  3552.  
  3553.  
  3554.  
  3555.  
  3556.  
  3557.  
  3558.  
  3559.  
  3560.  
  3561. VOID SetReqDefaults(char *szFilePath)
  3562. {
  3563. char *sFileStart;
  3564.  
  3565.  sFileStart = strrchr(szFilePath,'/');
  3566.  if (sFileStart == NULL)
  3567.      {
  3568.      sFileStart = strrchr(szFilePath,':');
  3569.      if (sFileStart == NULL)
  3570.          {
  3571.          sFileStart = szFilePath;
  3572.          }
  3573.      }
  3574.  
  3575.  if (sFileStart != NULL) strncpy(defFile,sFileStart+(sFileStart != szFilePath),sizeof(defFile));
  3576.  if ((sFileStart != NULL)&&(sFileStart != szFilePath)) strncpy(defDir,szFilePath,(sFileStart - szFilePath) + 1);
  3577.  return();
  3578. }
  3579.  
  3580.  
  3581.  
  3582.  
  3583.  
  3584.  
  3585. VOID UpperCase(char *sOldString)
  3586. {
  3587. char *i = sOldString;
  3588. const int diff = 'a' - 'A';
  3589.  
  3590.  if (sOldString == NULL) return();
  3591.  while (*i != CHAR_NUL)
  3592.  {
  3593.     if ((*i >= 'a')&&(*i <= 'z')) *i = *i - diff;
  3594.     i++;
  3595.  }
  3596. return();
  3597. }
  3598.  
  3599.  
  3600.  
  3601.  
  3602.  
  3603. VOID LowerCase(char *sOldString)
  3604. {
  3605. char *i = sOldString;
  3606. const int diff = 'a' - 'A';
  3607.  
  3608.  if (sOldString == NULL) return();
  3609.  while (*i != CHAR_NUL)
  3610.  {
  3611.     if ((*i >= 'A')&&(*i <= 'Z')) *i = *i + diff;
  3612.     i++;
  3613.  }
  3614.  
  3615. return();
  3616. }
  3617.  
  3618.  
  3619.  
  3620.  
  3621.  
  3622.  
  3623. int mgetoutput(void)
  3624. {
  3625.     FILE *fpTemp = NULL;
  3626.  
  3627.     if (getlist_length > 0) 
  3628.     {
  3629.         /* If no output name given, do default output... */
  3630.          if (strlen(sOutFileName) == 0)
  3631.          {
  3632.              /* for Workbench, absolute default is ram:GadMget.output */
  3633.              if (BStartedFromWB == TRUE)
  3634.              {
  3635.                  fpTemp = fopen("ram:Gadmget.Output","w");
  3636.                  if (fpTemp == NULL) 
  3637.                  {
  3638.                     MakeReq("Error:  Couldn't open ram:GadMget.output for writing!",NULL,NULL);
  3639.                     CleanUp();
  3640.                     exit(10);
  3641.                  }
  3642.              }
  3643.              else
  3644.              {    /* for the CLI, default is stdout */
  3645.                  fpTemp = stdout;
  3646.              }
  3647.          }
  3648.          else
  3649.          {
  3650.             /* open requested output file for writing */
  3651.             fpTemp = fopen(sOutFileName,"w");
  3652.             if (fpTemp == NULL)
  3653.             {
  3654.                 MakeReq("Error:  Couldn't open output file!",NULL,NULL);
  3655.             }
  3656.         }
  3657.             
  3658.          fpOut = fpTemp;
  3659.         PrintFile(szHeaderFile,0);
  3660.         if (noparse) RawOutputList(getlist);
  3661.                    else OutputList(getlist); 
  3662.         PrintFile(szFooterFile,1);
  3663.         if (fpOut != stdout) fclose(fpOut); else fflush(fpOut);
  3664.     }
  3665.     return(0);
  3666. }
  3667.  
  3668.  
  3669.  
  3670. VOID ParseCliArgs(int argc, char *argv[])
  3671. {
  3672.  int nextpasslookfor = 0;
  3673.  FILE *fpTemp = NULL;
  3674.  
  3675.  pcExecName = argv[0];
  3676.  
  3677.  memset(defDir,NUL,sizeof(defDir));
  3678.  memset(defFile,NUL,sizeof(defFile));
  3679.  memset(szHeaderFile,NUL,sizeof(szHeaderFile));
  3680.  memset(szFooterFile,NUL,sizeof(szFooterFile));
  3681.  memset(inputfile,NUL,sizeof(inputfile));
  3682.  
  3683.  if (argc > 1) 
  3684.  {
  3685.      strncpy(inputfile,argv[1],sizeof(inputfile));
  3686.      SetReqDefaults(inputfile);
  3687.  }
  3688.          
  3689.  if (*inputfile == '?')
  3690.  {
  3691.     fprintf(fpOut,"%s",template);
  3692.     CleanUp();
  3693.     exit(0);
  3694.  }
  3695.  
  3696.  for (int i=2; i<=argc; i++)
  3697.  {
  3698.     if (nextpasslookfor == 2)
  3699.     {
  3700.         strncpy(szPubScreenName,argv[i-1],sizeof(szPubScreenName));
  3701.         pubscreenname = szPubScreenName;
  3702.         screentype = USE_PUBSCREEN;
  3703.         continue;            /* skip to next loop */
  3704.     }
  3705.        if (nextpasslookfor == 7)         /* FILE PARAMETER */
  3706.      {
  3707.          strncpy(inputfile,argv[i-1],sizeof(inputfile));
  3708.          SetReqDefaults(inputfile);
  3709.      }
  3710.     if (nextpasslookfor == 9)        /* COMMAND PARAMETER */
  3711.     {
  3712.         strncpy(szCommandString,argv[i-1],sizeof(szCommandString));
  3713.     }
  3714.     if (nextpasslookfor == 16)    /* AMINETPATH PARAMETER */
  3715.     {
  3716.         strncpy(sAminetPathString,argv[i-1],sizeof(sAminetPathString));
  3717.     }
  3718.     if (nextpasslookfor == 17)    /* EOL PARAMETER */
  3719.     {
  3720.         strncpy(sEndOfLineString,argv[i-1],sizeof(sEndOfLineString));
  3721.         EOLParse(sEndOfLineString);
  3722.     }
  3723.     if (nextpasslookfor == 19)    /* COMMENTCHAR PARAMETER */
  3724.     {
  3725.         cCommentChar = *argv[i-1];
  3726.     }
  3727.  
  3728.     
  3729.     UpperCase(argv[i-1]);
  3730.  
  3731.     switch(nextpasslookfor)
  3732.     {    
  3733.     case(1):
  3734.         if (atoi(argv[i-1]) > 0)  maxoutputlinelength = atoi(argv[i-1]);
  3735.         break;
  3736.         
  3737.     /* case 2 is up above, before the Upper() command */
  3738.     
  3739.     case(3):        /* WIDTH PARAMETER */
  3740.         if (atoi(argv[i-1]) > 0)  windowwidth = 155;    /* min level */
  3741.         if (atoi(argv[i-1]) > 155) windowwidth = atoi(argv[i-1]);
  3742.         break;
  3743.     case(4):        /* HEIGHT PARAMETER */
  3744.         if (atoi(argv[i-1]) > 0) windowheight = 167;    /* min level */
  3745.         if (atoi(argv[i-1]) > 167) windowheight = atoi(argv[i-1]);
  3746.         break;
  3747.     case(5):        /* TOP PARAMETER */
  3748.         if (atoi(argv[i-1]) > 0) windowtop = atoi(argv[i-1]);
  3749.         break;
  3750.     case(6):        /* LEFT PARAMETER */
  3751.         if (atoi(argv[i-1]) > 0) windowleft = atoi(argv[i-1]);
  3752.         break;
  3753.         
  3754.     /* Case 7 is up above, before the Upper() command */
  3755.     
  3756.     case(8):        /* OUTPUT PARAMETER */
  3757.         strncpy(sOutFileName,argv[i-1],sizeof(sOutFileName));
  3758.         break;
  3759.     
  3760.     /* Case 9 is up above, before the Upper() command */
  3761.     
  3762.     case(10):        /* HEADER PARAMETER */
  3763.         strncpy(szHeaderFile,argv[i-1],sizeof(szHeaderFile));
  3764.         break;
  3765.         
  3766.     case(11):        /* FOOTER PARAMETER */
  3767.         strncpy(szFooterFile,argv[i-1],sizeof(szFooterFile));
  3768.         break;
  3769.  
  3770.     case(12):        /* FONT PARAMETER */
  3771.         strncpy(sListFontName,argv[i-1],sizeof(sListFontName));
  3772.         LowerCase(sListFontName);
  3773.         if (strstr(sListFontName,".font") == NULL) strncat(sListFontName,".font",sizeof(sListFontName));
  3774.         break;
  3775.         
  3776.     case(13):        /* FONTSIZE PARAMETER */
  3777.         if (atoi(argv[i-1]) > 0) nListFontSize = atoi(argv[i-1]);
  3778.         break;
  3779.     
  3780.     case(14):        /* FILESORT PARAMETER */
  3781.         LowerCase(argv[i-1]);
  3782.         if (strcmp(argv[i-1],"directory") == 0)   nSortType[0] = SORTBYDIR;
  3783.         if (strcmp(argv[i-1],"filename") == 0)    nSortType[0] = SORTBYNAME;
  3784.         if (strcmp(argv[i-1],"size") == 0)        nSortType[0] = SORTBYSIZE;
  3785.         if (strcmp(argv[i-1],"description") == 0) nSortType[0] = SORTBYDESC;
  3786.         if (strcmp(argv[i-1],"age") == 0)       nSortType[0] = SORTBYAGE;
  3787.         break;
  3788.             
  3789.     case(15):        /* GETSORT PARAMETER */
  3790.         LowerCase(argv[i-1]);
  3791.         if (strcmp(argv[i-1],"directory") == 0)   nSortType[1] = SORTBYDIR;
  3792.         if (strcmp(argv[i-1],"filename") == 0)    nSortType[1] = SORTBYNAME;
  3793.         if (strcmp(argv[i-1],"size") == 0)        nSortType[1] = SORTBYSIZE;
  3794.         if (strcmp(argv[i-1],"description") == 0) nSortType[1] = SORTBYDESC;
  3795.         if (strcmp(argv[i-1],"age") == 0)       nSortType[1] = SORTBYAGE;
  3796.         break;
  3797.  
  3798.     /* Case 16 is up above the Upper() command */
  3799.  
  3800.     /* Case 17 is up above the Upper() command */
  3801.     
  3802.     case(18):        /* FILEPAT PARAMETER */
  3803.         strncpy(szFilePattern,argv[i-1],sizeof(szFilePattern));
  3804.         break;
  3805.     
  3806.     /* Case 19 is up above the Upper() command */
  3807.  
  3808.     case(20):        /* LOADBUFFERS PARAMETER */
  3809.         nLoadBufferSize = atoi(argv[i-1]);
  3810.         if (nLoadBufferSize < 1) nLoadBufferSize = 1;
  3811.         nLoadBufferSize *= 1024;
  3812.         while ((nLoadBufferSize % 3) != 0) nLoadBufferSize++;
  3813.         break;
  3814.  
  3815.     case(21):        /* CLOSEACTION PARAMETER */
  3816.         LowerCase(argv[i-1]);
  3817.         if (strcmp(argv[i-1],"save") == 0)   nCloseAction = ACTION_SAVE;
  3818.         if (strcmp(argv[i-1],"output") == 0) nCloseAction = ACTION_OUTPUT;
  3819.         if ((strcmp(argv[i-1],"saveoutput") == 0)||(strcmp(argv[i-1],"outputsave") == 0)) 
  3820.                              nCloseAction = (ACTION_OUTPUT | ACTION_SAVE);
  3821.         if ((strcmp(argv[i-1],"quit") == 0)||(strcmp(argv[i-1],"none") == 0)) 
  3822.                              nCloseAction  = ACTION_NONE;
  3823.         break;
  3824.         
  3825.                         
  3826.     default:
  3827.         /* nothing */
  3828.         break;        
  3829.     }
  3830.     nextpasslookfor = 0;
  3831.     if (strcmp(argv[i-1],"NOAPPWINDOW") == 0)         appwindow = FALSE;
  3832.     if (strcmp(argv[i-1],"SEARCHCASESENSITIVE") == 0) searchcasesensitive = TRUE;    
  3833.     if (strcmp(argv[i-1],"SORTCASESENSITIVE") == 0)   sortcasesensitive= TRUE;    
  3834.     if (strcmp(argv[i-1],"CASESENSITIVE") == 0) 
  3835.     {
  3836.         sortcasesensitive= TRUE;    
  3837.         searchcasesensitive = TRUE;
  3838.     }
  3839.  
  3840.     if (strcmp(argv[i-1],"NOPARSE") == 0)         noparse = TRUE;
  3841.     if (strcmp(argv[i-1],"NOCOMMAND") == 0)     nocommand = TRUE;
  3842.     if (strcmp(argv[i-1],"NOSPLIT") == 0)         nosplit = TRUE;
  3843.     if (strcmp(argv[i-1],"GETREADMES") == 0)     getreadmes = TRUE;    
  3844.     if (strcmp(argv[i-1],"NOCD") == 0)        nocd = TRUE;
  3845.        if (strcmp(argv[i-1],"NOFILES") == 0) 
  3846.        {
  3847.             filesflag  = FALSE;
  3848.             getreadmes = TRUE;
  3849.         }
  3850.      if (strcmp(argv[i-1],"LINELENGTH") == 0)        nextpasslookfor= 1;
  3851.      if (strcmp(argv[i-1],"PUBSCREEN") == 0)        nextpasslookfor= 2;
  3852.     if (strcmp(argv[i-1],"DEFPUBSCREEN") == 0)    screentype = USE_PUBSCREEN;     
  3853.     if ((strcmp(argv[i-1],"WBSCREEN") == 0)||
  3854.         (strcmp(argv[i-1],"WORKBENCHSCREEN") == 0)) screentype = USE_WBSCREEN;
  3855.     if (strcmp(argv[i-1],"NOSIMPLEPATHS") == 0)    simplepaths  = FALSE;    
  3856.     if (strcmp(argv[i-1],"KEEPBLANKLINES") == 0)    keepblanklines = TRUE;
  3857.     if (strcmp(argv[i-1],"KEEPFILESSORT") == 0)     nKeepSorted[0] = TRUE;
  3858.     if (strcmp(argv[i-1],"KEEPGETSORT") == 0)       nKeepSorted[1] = TRUE;
  3859.     if (strcmp(argv[i-1],"OMITCOMMENTS") == 0)      omitcomments = TRUE;
  3860.                                                                                     
  3861.     if (strcmp(argv[i-1],"WIDTH") == 0)    nextpasslookfor = 3;
  3862.     if (strcmp(argv[i-1],"HEIGHT") == 0)    nextpasslookfor = 4;
  3863.     if (strcmp(argv[i-1],"TOP") == 0)    nextpasslookfor = 5;
  3864.     if (strcmp(argv[i-1],"LEFT") == 0)    nextpasslookfor = 6;
  3865.     if (strcmp(argv[i-1],"FILE") == 0)    nextpasslookfor = 7;
  3866.     if (strcmp(argv[i-1],"OUTPUT") == 0)    nextpasslookfor = 8;
  3867.     if (strcmp(argv[i-1],"COMMAND") == 0)    nextpasslookfor = 9;
  3868.     if (strcmp(argv[i-1],"HEADER") == 0)    nextpasslookfor = 10;
  3869.     if (strcmp(argv[i-1],"FOOTER") == 0)    nextpasslookfor = 11;
  3870.     if (strcmp(argv[i-1],"FONT") == 0)      nextpasslookfor = 12;
  3871.     if ((strcmp(argv[i-1],"FONTSIZE") == 0) ||
  3872.         (strcmp(argv[i-1],"SIZE") == 0))    nextpasslookfor = 13;
  3873.     if (strcmp(argv[i-1],"FILESORT") == 0)  nextpasslookfor = 14;
  3874.     if (strcmp(argv[i-1],"GETSORT") == 0)   nextpasslookfor = 15;
  3875.     if (strcmp(argv[i-1],"AMINETPATH") == 0)nextpasslookfor = 16;
  3876.     if (strcmp(argv[i-1],"EOL") == 0)       nextpasslookfor = 17;
  3877.     if ((strcmp(argv[i-1],"FILEPAT") == 0)||
  3878.         (strcmp(argv[i-1],"FILEPATTERN") == 0)) nextpasslookfor = 18;
  3879.     if (strcmp(argv[i-1],"COMMENTCHAR") == 0)   nextpasslookfor = 19;
  3880.     if (strcmp(argv[i-1],"LOADBUFFERS") == 0)   nextpasslookfor = 20;
  3881.     if (strcmp(argv[i-1],"CLOSEACTION") == 0)   nextpasslookfor = 21;
  3882.  }
  3883.  
  3884. return();
  3885. }
  3886.  
  3887.  
  3888.  
  3889.  
  3890.  
  3891.  
  3892.  
  3893.  
  3894.  
  3895.  
  3896. VOID wbmain(struct WBStartup *argv)
  3897. {
  3898.     BStartedFromWB = TRUE;
  3899.     IconBase = OpenLibrary("icon.library",33);
  3900.     if (IconBase == NULL) exit(2);
  3901.     ParseWBArgs(argv);
  3902.     pcExecName = (struct WBStartup *)argv->sm_ArgList->wa_Name;
  3903.     main(0,argv);
  3904. }
  3905.  
  3906.  
  3907.  
  3908.  
  3909.  
  3910.  
  3911.  
  3912.  
  3913. VOID ParseWBArgs(struct WBStartup *argv)
  3914. {
  3915. struct WBArg *wb_arg = argv->sm_ArgList;
  3916. struct DiskObject *dobj;
  3917. char **toolarray, *sTemp;
  3918. FILE *fpTemp = NULL;
  3919.  
  3920.  
  3921. memset(defDir,NUL,sizeof(defDir));
  3922. memset(defFile,NUL,sizeof(defFile));
  3923. memset(szHeaderFile,NUL,sizeof(szHeaderFile));
  3924. memset(szFooterFile,NUL,sizeof(szFooterFile));
  3925.  
  3926.  
  3927. /* Parse the tooltypes from the program file */
  3928. dobj = GetDiskObject(wb_arg->wa_Name);
  3929.  
  3930. if (dobj != NULL)
  3931.  {
  3932.      toolarray = (char **) dobj->do_ToolTypes;
  3933.     if (toolarray != NULL)
  3934.     {
  3935.     
  3936.         if (sTemp = (char *) FindToolType(toolarray,"OUTPUT")) 
  3937.         {
  3938.           strncpy(sOutFileName,sTemp,sizeof(sOutFileName));
  3939.         }
  3940.                                             
  3941.         if (sTemp = (char *) FindToolType(toolarray,"FILE")) 
  3942.         {
  3943.             strncpy(inputfile,sTemp,sizeof(inputfile));
  3944.             SetReqDefaults(inputfile);
  3945.         }
  3946.         if (sTemp = (char *) FindToolType(toolarray,"NOPARSE"))       noparse     = TRUE;
  3947.         if (sTemp = (char *) FindToolType(toolarray,"NOCOMMAND"))      nocommand   = TRUE;
  3948.            if (sTemp = (char *) FindToolType(toolarray,"NOSPLIT"))       nosplit     = TRUE;    
  3949.            if (sTemp = (char *) FindToolType(toolarray,"OMITCOMMENTS"))       omitcomments = TRUE;    
  3950.            if (sTemp = (char *) FindToolType(toolarray,"GETREADMES"))  getreadmes  = TRUE;
  3951.         if (sTemp = (char *) FindToolType(toolarray,"NOFILES"))
  3952.         {
  3953.             filesflag     = FALSE;
  3954.                 getreadmes  = TRUE;
  3955.         }
  3956.            if (sTemp = (char *) FindToolType(toolarray,"LINELENGTH"))
  3957.            {
  3958.                if (atoi(sTemp) > 0)  maxoutputlinelength = atoi(sTemp); 
  3959.            }
  3960.                   
  3961.           if (sTemp = (char *) FindToolType(toolarray,"PUBSCREEN"))   
  3962.           {
  3963.               strcpy(szPubScreenName,sTemp);
  3964.               pubscreenname = szPubScreenName;
  3965.               screentype = USE_PUBSCREEN;
  3966.           }
  3967.           
  3968.           if (sTemp = (char *) FindToolType(toolarray,"NOSIMPLEPATHS"))    simplepaths = FALSE;        
  3969.           if (sTemp = (char *) FindToolType(toolarray,"NOPARSE"))       noparse = TRUE;        
  3970.         if (sTemp = (char *) FindToolType(toolarray,"NOAPPWINDOW"))     appwindow = FALSE;
  3971.         if (sTemp = (char *) FindToolType(toolarray,"WBSCREEN"))      screentype = USE_WBSCREEN;
  3972.         if (sTemp = (char *) FindToolType(toolarray,"WORKBENCHSCREEN")) screentype = USE_WBSCREEN;                                
  3973.         if (sTemp = (char *) FindToolType(toolarray,"NOCD"))        nocd = TRUE;
  3974.         if (sTemp = (char *) FindToolType(toolarray,"KEEPBLANKLINES"))     keepblanklines = TRUE;
  3975.         if (sTemp = (char *) FindToolType(toolarray,"KEEPFILESORT"))     nKeepSorted[0] = TRUE;
  3976.         if (sTemp = (char *) FindToolType(toolarray,"KEEPGETSORT"))     nKeepSorted[1] = TRUE;
  3977.         
  3978.         if (sTemp = (char *) FindToolType(toolarray,"WIDTH"))                             
  3979.         {
  3980.             if (atoi(sTemp) > 0)  windowwidth = 155;    /* min level */
  3981.             if (atoi(sTemp) > 155) windowwidth = atoi(sTemp);
  3982.         }
  3983.         if (sTemp = (char *) FindToolType(toolarray,"HEIGHT"))     
  3984.         {                        
  3985.             if (atoi(sTemp) > 0) windowheight = 167;    /* min level */
  3986.             if (atoi(sTemp) > 167) windowheight = atoi(sTemp);
  3987.         }
  3988.         if (sTemp = (char *) FindToolType(toolarray,"TOP"))                             
  3989.         {
  3990.             if (atoi(sTemp) > 0) windowtop = atoi(sTemp);
  3991.         }
  3992.         if (sTemp = (char *) FindToolType(toolarray,"LEFT"))                             
  3993.         {
  3994.             if (atoi(sTemp) > 0) windowleft = atoi(sTemp);
  3995.         }                    
  3996.         if (sTemp = (char *) FindToolType(toolarray,"SEARCHCASESENSITIVE"))                             
  3997.         {
  3998.             searchcasesensitive = 1;
  3999.         }
  4000.         if (sTemp = (char *) FindToolType(toolarray,"SORTCASESENSITIVE"))                             
  4001.         {
  4002.             sortcasesensitive = 1;
  4003.         }
  4004.         if (sTemp = (char *) FindToolType(toolarray,"CASESENSITIVE"))                             
  4005.         {
  4006.             searchcasesensitive = 1;
  4007.             sortcasesensitive = 1;
  4008.         }
  4009.  
  4010.         if (sTemp = (char *) FindToolType(toolarray,"COMMAND"))
  4011.         {
  4012.             strncpy(szCommandString,sTemp,sizeof(szCommandString));
  4013.         }
  4014.         if (sTemp = (char *) FindToolType(toolarray,"HEADER"))
  4015.         {
  4016.             strncpy(szHeaderFile,sTemp,sizeof(szHeaderFile));
  4017.         }
  4018.         if (sTemp = (char *) FindToolType(toolarray,"FOOTER"))
  4019.         {
  4020.             strncpy(szFooterFile,sTemp,sizeof(szFooterFile));
  4021.         }
  4022.         if (sTemp = (char *) FindToolType(toolarray,"FONT"))
  4023.         {
  4024.             strncpy(sListFontName,sTemp,sizeof(sListFontName));
  4025.             LowerCase(sListFontName);
  4026.             if (strstr(sListFontName,".font") == NULL) strncat(sListFontName,".font",sizeof(sListFontName));
  4027.         }
  4028.         if (sTemp = (char *) FindToolType(toolarray,"FONTSIZE"))
  4029.         {
  4030.             if (atoi(sTemp) > 0) nListFontSize = atoi(sTemp);
  4031.         }
  4032.         if (sTemp = (char *) FindToolType(toolarray,"SIZE"))
  4033.         {
  4034.             if (atoi(sTemp) > 0) nListFontSize = atoi(sTemp);
  4035.         }
  4036.         if (sTemp = (char *) FindToolType(toolarray,"FILESORT"))
  4037.         {
  4038.             LowerCase(sTemp);
  4039.             if (strcmp(sTemp,"directory") == 0)   nSortType[0] = SORTBYDIR;
  4040.             if (strcmp(sTemp,"filename") == 0)    nSortType[0] = SORTBYNAME;
  4041.             if (strcmp(sTemp,"size") == 0)        nSortType[0] = SORTBYSIZE;
  4042.             if (strcmp(sTemp,"description") == 0) nSortType[0] = SORTBYDESC;
  4043.             if (strcmp(sTemp,"age") == 0)           nSortType[0] = SORTBYAGE;
  4044.         }
  4045.         if (sTemp = (char *) FindToolType(toolarray,"GETSORT"))
  4046.         {
  4047.             LowerCase(sTemp);
  4048.             if (strcmp(sTemp,"directory") == 0)   nSortType[1] = SORTBYDIR;
  4049.             if (strcmp(sTemp,"filename") == 0)    nSortType[1] = SORTBYNAME;
  4050.             if (strcmp(sTemp,"size") == 0)        nSortType[1] = SORTBYSIZE;
  4051.             if (strcmp(sTemp,"description") == 0) nSortType[1] = SORTBYDESC;
  4052.             if (strcmp(sTemp,"age") == 0)           nSortType[1] = SORTBYAGE;
  4053.         }    
  4054.                         
  4055.         if (sTemp = (char *) FindToolType(toolarray,"AMINETPATH"))
  4056.             strncpy(sAminetPathString,sTemp,sizeof(sAminetPathString));
  4057.  
  4058.         if (sTemp = (char *) FindToolType(toolarray,"FILEPAT"))
  4059.             strncpy(szFilePattern,sTemp,sizeof(szFilePattern));
  4060.         if (sTemp = (char *) FindToolType(toolarray,"FILEPATTERN"))
  4061.             strncpy(szFilePattern,sTemp,sizeof(szFilePattern));
  4062.  
  4063.         if (sTemp = (char *) FindToolType(toolarray,"EOL"))
  4064.         {
  4065.             strncpy(sEndOfLineString,sTemp,sizeof(sEndOfLineString));
  4066.             EOLParse(sEndOfLineString);
  4067.         }
  4068.         
  4069.         if (sTemp = (char *) FindToolType(toolarray,"COMMENTCHAR"))
  4070.         {
  4071.             cCommentChar = (*sTemp);
  4072.         }                
  4073.         if (sTemp = (char *) FindToolType(toolarray,"LOADBUFFERS"))
  4074.         {
  4075.             nLoadBufferSize = atoi(sTemp);
  4076.             if (nLoadBufferSize < 1) nLoadBufferSize = 1;
  4077.             nLoadBufferSize *= 1024;
  4078.             while ((nLoadBufferSize % 3) != 0) nLoadBufferSize++;
  4079.         }                
  4080.         if (sTemp = (char *) FindToolType(toolarray,"CLOSEACTION"))
  4081.         {
  4082.             LowerCase(sTemp);
  4083.             if (strcmp(sTemp,"save") == 0)   nCloseAction = ACTION_SAVE;
  4084.             if (strcmp(sTemp,"output") == 0) nCloseAction = ACTION_OUTPUT;
  4085.             if ((strcmp(sTemp,"saveoutput") == 0)||(strcmp(sTemp,"outputsave") == 0)) 
  4086.                              nCloseAction = (ACTION_OUTPUT | ACTION_SAVE);
  4087.             if ((strcmp(sTemp,"none") == 0)||(strcmp(sTemp,"quit") == 0))
  4088.                                  nCloseAction  = ACTION_NONE;
  4089.         }
  4090.     }
  4091.  FreeDiskObject(dobj);
  4092.  }
  4093.  
  4094.  /* Get the name of the file extended_clicked, if there is one */
  4095.  if (argv->sm_NumArgs > 1) 
  4096.  {
  4097.     wb_arg++;    /* The first name is the programs name, the 2nd is the proj. icon */
  4098.     if (wb_arg->wa_Name != NULL) 
  4099.     {
  4100.         strncpy(inputfile,wb_arg->wa_Name,sizeof(inputfile));
  4101.         CurrentDir(wb_arg->wa_Lock);
  4102.     }
  4103.  }
  4104.     
  4105. return();
  4106. }
  4107.  
  4108.  
  4109.  
  4110.  
  4111. /* If arg is TRUE, handle via AppWindow, else via AppIcon */
  4112. /* The first file is loaded, the rest are appended */
  4113. BOOL HandleAppEvents(struct MsgPort *msgport)
  4114. {    
  4115.     struct AppMessage * amsg;
  4116.     struct WBArg *argptr = NULL;
  4117.     int nReturn = 0,i;
  4118.     char szFilePath[MAXFILENAMELENGTH];
  4119.     
  4120.     while (amsg = (struct AppMessage *) GetMsg(msgport))
  4121.     {
  4122.         if (screenisopen == 0) 
  4123.         {
  4124.             if (SetupScreen() > 0) 
  4125.             {
  4126.                 printf("GadMget: couldn't reopen screen!\n");
  4127.                 CleanUp();
  4128.                 exit(5);
  4129.             }
  4130.         }
  4131.         
  4132.         if (windowisopen == 0)
  4133.         {
  4134.             if (OpenmgetWindow() > 0)
  4135.             {
  4136.                 printf("GadMget: Couldn't reopen window!\n");
  4137.                 CleanUp();
  4138.                 exit(5);
  4139.             }
  4140.         }
  4141.  
  4142.         
  4143.         /* process messages */
  4144.         if (amsg->am_NumArgs > 0L)
  4145.         {
  4146.             for (i=0;i<amsg->am_NumArgs;i++)
  4147.             {
  4148.                 if (NameFromLock(amsg->am_ArgList[i].wa_Lock, szFilePath, sizeof(szFilePath)))
  4149.                 {
  4150.                     if (szFilePath[strlen(szFilePath)-1] != ':') strncat(szFilePath,"/", sizeof(szFilePath));
  4151.                     strncat(szFilePath, amsg->am_ArgList[i].wa_Name, sizeof(szFilePath));
  4152.                     if (i==0) OpenMgetFile(szFilePath);
  4153.                          else AppendMgetFile(szFilePath);
  4154.                 }
  4155.             }
  4156.         }
  4157.         /* done with message, release it */
  4158.         ReplyMsg((struct Message *)amsg);
  4159.     }
  4160.     return(TRUE);
  4161. }
  4162.  
  4163.  
  4164.  
  4165.  
  4166.  
  4167.  
  4168.  
  4169.  
  4170.  
  4171.  
  4172. /********/
  4173. /* MAIN */
  4174. /********/
  4175. VOID main(int argc, char *argv[])
  4176. {
  4177. FILE *test = NULL;
  4178. ULONG winsig,signals;
  4179.  
  4180. GraphicsBase = OpenLibrary("graphics.library",37);
  4181.  if (GraphicsBase==NULL)
  4182.     {
  4183.     fprintf(fpOut,"couldn't open Graphics.library v37!");
  4184.     CleanUp();
  4185.     return;
  4186.     }
  4187. UtilityBase = OpenLibrary("utility.library",37);
  4188.  if (UtilityBase==NULL)
  4189.     {
  4190.     fprintf(fpOut,"couldn't open utility.library v37!");
  4191.     CleanUp();
  4192.     return;
  4193.     }
  4194. GadToolsBase = OpenLibrary("gadtools.library",37);
  4195.  if (GadToolsBase==NULL)
  4196.     {
  4197.     fprintf(fpOut,"couldn't open gadtools.library v37!\n");
  4198.     CleanUp();
  4199.     return;
  4200.     }
  4201. AslBase = OpenLibrary("asl.library", 37L);
  4202.  if (AslBase == NULL)
  4203.     {
  4204.     fprintf(fpOut,"couldn't open asl.library v37!\n");
  4205.     CleanUp();
  4206.     return;
  4207.     }
  4208. IntuitionBase = OpenLibrary("intuition.library",37);
  4209.  if (IntuitionBase == NULL)
  4210.      {
  4211.      fprintf(fpOut,"Couldn't open intuition.library!\n");
  4212.      CleanUp();
  4213.      return;
  4214.      }
  4215. WorkbenchBase = OpenLibrary("workbench.library",37);
  4216.  if (WorkbenchBase == NULL)
  4217.      {
  4218.      fprintf(fpOut,"Couldn't open workbench.library!\n");
  4219.      CleanUp();
  4220.      return;
  4221.      }
  4222. if (IconBase == NULL)
  4223. {
  4224.     IconBase = OpenLibrary("icon.library",33);
  4225.     /* If it's NULL, we'll disable the iconify function */
  4226. }
  4227.  
  4228.  
  4229. /* construct program name from version string */
  4230. memset(pnamestring,NUL,20);
  4231. strcpy(pnamestring,version+6);
  4232.  
  4233. memset(searchstring,NUL,sizeof(searchstring));
  4234.  
  4235. if (argc>1) ParseCliArgs(argc,argv);
  4236.      
  4237. /* Now add data to listView */
  4238. /* First, initialize List filelist */
  4239.     
  4240. #ifdef MEMPOOLS_H
  4241.  if (!(filelist = (struct List *) malloc(sizeof(struct List))) )
  4242. #else
  4243.  if (!(filelist = AllocMem(sizeof(struct List),MEMF_CLEAR)) )
  4244. #endif
  4245.     {
  4246.     MakeReq("Couldn't create filelist!  Out of memory?",NULL,NULL);
  4247.     CleanUp();
  4248.     return();
  4249.     }
  4250.     
  4251. #ifdef MEMPOOLS_H
  4252.  if (!(getlist = (struct List *) malloc(sizeof(struct List))) )
  4253. #else
  4254.  if (!(getlist = AllocMem(sizeof(struct List),MEMF_CLEAR)) )
  4255. #endif
  4256.     {
  4257.     MakeReq("Couldn't create getlist!  Out of memory?",NULL,NULL);
  4258.     CleanUp();
  4259.     return();
  4260.     }
  4261.     
  4262.  NewList(filelist);
  4263.  NewList(getlist);
  4264.  
  4265.  if ((pcExecName == NULL)||(strlen(pcExecName) == 0)) pcExecName = DEFAULT_EXECNAME;
  4266.  
  4267.  lockscrnerror = SetupScreen();
  4268.  if (lockscrnerror)
  4269.  {
  4270.     if (BStartedFromWB == FALSE) printf("Couldn't open screen!\n",NULL,"Sigh");
  4271.     else
  4272.     MakeReq("Couldn't open screen!",NULL,NULL);
  4273.     
  4274.     CleanUp();
  4275.     return();
  4276.  }
  4277.     
  4278.  winopenerror = OpenmgetWindow();
  4279.  if (winopenerror)
  4280.  {
  4281.     MakeReq("Couldn't open window!",NULL,NULL);
  4282.     CleanUp();
  4283.     return();
  4284.  }
  4285.  
  4286.  if ((OpenMgetFile(inputfile) == TRUE)||(OpenMgetFile(NULL) == TRUE))
  4287.  {
  4288.     /* First, make sure all the menus are enabled. */
  4289.     TurnOnAllMenuItems(mgetMenus);
  4290.     
  4291.     SetMenuValues();
  4292.  
  4293.     if (noparse) SetWindowTitles(mgetWnd, "Please select desired lines now." , (char *) ~0); 
  4294.            else ChangeWindowTitle();
  4295.     
  4296.     while (done==FALSE)
  4297.     {
  4298.         winsig = 1L << mgetWnd->UserPort->mp_SigBit;
  4299.         signals = Wait(winsig|appwinsig);
  4300.         if (signals&winsig) handlereturn = HandlemgetIDCMP(NULL);
  4301.         if (signals&appwinsig) HandleAppEvents(awport);
  4302.     }
  4303.     if (windowisopen)  ClosemgetWindow();
  4304.     if (screenisopen)  CloseDownScreen();
  4305.     
  4306.     if (nCloseAction & ACTION_SAVE)   mgetsave();
  4307.     if (nCloseAction & ACTION_OUTPUT) mgetoutput();    
  4308.  }
  4309.  CleanUp();
  4310.         
  4311.  exit(0);    
  4312. }
  4313.  
  4314. #endif
  4315.  
  4316.  
  4317.